Bagaimana saya bisa menguji GUI?

Perhitungan dalam kode saya sudah teruji dengan baik, tetapi karena ada begitu banyak kode GUI, cakupan kode saya secara keseluruhan lebih rendah dari yang saya inginkan. Apakah ada pedoman tentang kode GUI pengujian unit? Apakah itu masuk akal?

Misalnya, ada grafik di aplikasi saya. Saya belum dapat menemukan cara mengotomatiskan pengujian grafik. Dibutuhkan mata manusia, AFAIK, untuk memeriksa apakah grafiknya benar.

(Saya menggunakan Java Swing)

Desain seperti MVP dan MVC biasanya mencoba untuk abstrak logika sebanyak mungkin dari GUI yang sebenarnya. Satu artikel yang sangat populer tentang ini adalah "The Humble Dialog Box" oleh Michael Feathers. Secara pribadi saya memiliki pengalaman yang beragam dengan mencoba untuk mengeluarkan logika dari UI - kadang-kadang itu bekerja dengan sangat baik, dan di lain waktu itu lebih banyak masalah daripada nilainya. Ini agak di luar bidang keahlian saya.

Tentu saja, jawabannya adalah menggunakan MVC dan memindahkan logika sebanyak mungkin dari GUI.

Yang sedang berkata, saya mendengar dari seorang rekan kerja dulu bahwa ketika SGI porting OpenGL ke perangkat keras baru, mereka memiliki banyak unit tes yang akan menarik set primitif ke layar kemudian menghitung jumlah MD5 dari buffer bingkai. Nilai ini kemudian dapat dibandingkan dengan nilai hash baik yang diketahui untuk dengan cepat menentukan apakah API akurat per piksel.

Anda dapat mencoba UISpec4J adalah pustaka pengujian fungsional dan / atau unit Open Source untuk aplikasi Java berbasis ...

Ada Selenium RC , yang akan mengotomatisasi pengujian UI berbasis web. Ini akan merekam tindakan dan mengulanginya. Anda masih harus berjalan melalui interaksi dengan UI Anda, jadi ini tidak akan membantu dengan cakupan, tetapi dapat digunakan untuk pembuatan otomatis.

Anda dapat mencoba menggunakan Mentimun dan Swinger untuk menulis tes penerimaan fungsional dalam bahasa Inggris untuk aplikasi Swing GUI. Swinger menggunakan perpustakaan Jemmy Netbeans di bawah tenda untuk mendorong aplikasi.

Mentimun memungkinkan Anda untuk menulis tes seperti ini:

 Scenario: Dialog manipulation
    Given the frame "SwingSet" is visible
    When I click the menu "File/About"
    Then I should see the dialog "About Swing!"
    When I click the button "OK"
    Then I should not see the dialog "About Swing!"

Lihatlah demo video Swinger ini untuk melihatnya beraksi.

Berikut ini beberapa tips:

Cobalah untuk menghapus kode terbanyak yang Anda dapat dari GUI (memiliki pengontrol, dan objek model) dengan cara ini Anda akan dapat mengujinya tanpa GUI.

Untuk grafik, Anda harus menguji nilai yang Anda berikan ke kode yang menghasilkan grafik.

Pengujian adalah bentuk seni. Saya setuju bahwa logika harus dihapus GUI sebanyak mungkin. Kami kemudian dapat memfokuskan pengujian unit kami di sana. Seperti apa pun pengujian adalah tentang mengurangi risiko. Anda tidak selalu perlu menguji semuanya tetapi banyak kali hal terbaik adalah untuk memecah pengujian yang berbeda untuk di daerah yang berbeda.

Pertanyaan lain adalah apa yang benar-benar Anda coba untuk menguji pada lapisan UI. Pengujian UI adalah pengujian yang paling mahal karena biasanya membutuhkan waktu lebih lama untuk membuat, memelihara, dan paling rapuh. Jika Anda menguji logika untuk mengetahui koordinat yang benar sebelum mencoba menggambar garis apa yang Anda uji secara spesifik? Jika Anda ingin menguji grafik dengan garis merah ditarik. Bisakah Anda memberikannya satu set koordinat yang telah ditentukan dan menguji apakah piksel tertentu berwarna merah atau tidak merah? Seperti yang disarankan di atas, perbandingan bitmap berfungsi, Selenium tetapi fokus utama saya adalah tidak menguji GUI secara berlebihan, melainkan menguji logika yang akan membantu membuat UI dan kemudian fokus pada bagian apa dari UI yang terputus atau dicurigai dan memfokuskan beberapa pengujian. sana.

Anda dapat menggunakan JFCUnit untuk menguji GUI Anda, tetapi grafik bisa lebih menantang. Saya beberapa kali mengambil snapshot GUI saya dan secara otomatis membandingkannya dengan versi sebelumnya. Meskipun ini tidak memberikan tes yang sebenarnya, itu memperingatkan Anda jika sebuah bangunan otomatis gagal menghasilkan output yang diharapkan.

Apa yang saya kumpulkan dari pertanyaan Anda adalah bahwa Anda mencari cara otomatis untuk menguji perilaku GUI Anda secara detail, contoh yang Anda berikan adalah menguji apakah suatu kurva benar-benar digambar dengan benar.

Kerangka kerja pengujian unit menyediakan cara untuk melakukan pengujian otomatis, tapi saya pikir jenis tes yang ingin Anda lakukan adalah tes integrasi rumit yang memverifikasi perilaku yang benar dari banyak kelas, di antaranya kelas toolkit / library GUI Anda, yang Anda seharusnya tidak ingin menguji.

Opsi Anda sangat bergantung pada platform / toolkit / kerangka kerja apa yang Anda gunakan: misalnya, aplikasi yang menggunakan Qt sebagai kerangka GUI dapat menggunakan Squish untuk mengotomatiskan pengujiannya. Anda memverifikasi hasil pengujian Anda satu kali, dan tes yang dilakukan secara otomatis berikutnya membandingkan hasil dengan hasil yang diverifikasi.

Window Licker untuk Swing & Ajax

Pendekatan saya terhadap pengujian GUI terus berkembang, seperti halnya konsensus industri. Tapi saya pikir beberapa teknik utama mulai muncul.

Saya menggunakan satu atau lebih dari teknik-teknik ini, tergantung pada situasinya (misalnya GUI seperti apa, seberapa cepat perlu dibangun, siapa pengguna akhir, dll.).

1. Pengujian manual. Anda selalu menjalankan GUI saat mengerjakan kode, dan memastikannya sinkron dengan kode. Anda secara manual menguji dan menguji ulang bagian yang Anda kerjakan saat Anda mengerjakannya, beralih antara kode dan aplikasi yang sedang berjalan. Setiap kali Anda menyelesaikan beberapa pekerjaan penting, Anda memberikan seluruh layar atau area aplikasi tes keseluruhan, untuk memastikan tidak ada regresi.

2. Pengujian unit. Anda menulis tes untuk fungsi atau unit kecil perilaku GUI. Misalnya, grafik Anda mungkin perlu menghitung berbagai nuansa warna berdasarkan warna 'dasar'. Anda dapat mengekstrak perhitungan ini ke suatu fungsi dan menulis unit test untuknya. Anda dapat mencari logika seperti ini di GUI (terutama logika yang dapat digunakan kembali) dan mengekstraknya menjadi fungsi-fungsi rahasia, yang dapat lebih mudah diuji unit. Bahkan perilaku kompleks dapat diekstraksi dan diuji dengan cara ini - misalnya, urutan langkah-langkah dalam wizard dapat diekstraksi ke suatu fungsi dan unit-tes dapat memverifikasi bahwa, diberi input, langkah yang benar dikembalikan.

3. Penjelajah komponen. Anda membuat layar 'penjelajah' yang perannya hanya untuk menampilkan setiap komponen yang dapat digunakan kembali yang membentuk GUI Anda. Layar ini memberi Anda cara cepat dan mudah untuk memverifikasi secara visual bahwa setiap komponen memiliki tampilan & rasa yang benar. Penjelajah komponen lebih efisien daripada secara manual menelusuri seluruh aplikasi Anda, karena A) Anda hanya perlu memverifikasi setiap komponen sekali, dan B) Anda tidak perlu menavigasi jauh ke dalam aplikasi untuk melihat komponen, Anda hanya dapat melihat dan segera verifikasi itu.

4. Pengujian otomasi. Anda menulis tes yang berinteraksi dengan layar atau komponen, mensimulasikan klik mouse, entri data, dll., Menyatakan bahwa fungsi aplikasi dengan benar diberikan manipulasi ini. Ini dapat berguna sebagai tes cadangan tambahan, untuk menangkap bug potensial yang mungkin terlewatkan oleh tes Anda yang lain. Saya cenderung memesan pengujian otomasi untuk bagian-bagian GUI yang paling rentan rusak dan / atau sangat kritis. Bagian yang ingin saya ketahui sedini mungkin jika ada sesuatu yang rusak. Ini dapat mencakup komponen interaktif yang sangat kompleks yang rentan terhadap kerusakan atau layar utama yang penting.

5. Pengujian dif / snapshot. Anda menulis tes yang hanya menangkap output sebagai tangkapan layar atau sebagai kode HTML dan membandingkannya dengan output sebelumnya. Dengan begitu, Anda memberi tahu Anda setiap kali output berubah. Tes diff mungkin berguna jika aspek visual GUI Anda kompleks dan / atau dapat berubah, dalam hal ini, Anda ingin umpan balik cepat dan visual tentang apa dampak perubahan yang diberikan pada GUI secara keseluruhan.

Daripada menggunakan semua jenis tes yang mungkin, saya lebih memilih untuk memilih dan memilih teknik pengujian berdasarkan pada jenis hal yang saya kerjakan. Jadi dalam satu kasus saya akan mengekstrak fungsi sederhana dan mengujinya, tetapi dalam kasus lain saya akan menambahkan komponen ke komponen explorer, dll. Itu tergantung pada situasinya.

Saya belum menemukan cakupan kode menjadi metrik yang sangat berguna, tetapi orang lain mungkin menemukan manfaatnya.

Saya pikir langkah pertama adalah jumlah dan tingkat keparahan bug. Prioritas pertama Anda mungkin memiliki aplikasi yang berfungsi dengan benar. Jika aplikasi berfungsi dengan benar, seharusnya ada sedikit atau tidak ada bug. Jika ada banyak atau bug yang parah, maka mungkin, Anda tidak sedang menguji atau tes Anda tidak efektif.

Selain mengurangi bug, ada langkah-langkah lain seperti kinerja, kegunaan, aksesibilitas, pemeliharaan, ekstensibilitas, dll. Ini akan berbeda, tergantung pada jenis aplikasi yang Anda bangun, bisnis, pengguna akhir, dll.

Ini semua berdasarkan pengalaman pribadi dan penelitian saya serta tulisan yang bagus tentang Tes UI oleh Ham Vocke .

Dari yang saya tahu, ini cukup rumit, dan sangat tergantung pada bahasanya - banyak bahasa memiliki cara sendiri untuk menguji GUI, tetapi jika Anda benar-benar perlu menguji GUI (sebagai lawan dari interaksi model / gui), Anda sering harus mensimulasikan tombol mengklik pengguna yang sebenarnya. Misalnya, kerangka kerja SWT yang digunakan dalam Eclipse menyediakan SWTBot , JFCUnit telah disebutkan, Mozilla memiliki cara mereka sendiri dalam mensimulasikan ini dalam XUL (dan dari apa yang saya baca di blog mereka, tes ini tampaknya cukup rapuh).

Kadang-kadang Anda harus mengambil tangkapan layar, dan menguji rendering piksel-sempurna (saya percaya bahwa Mozilla melakukan ini untuk memeriksa halaman yang dirender dengan benar) - ini memerlukan pengaturan yang lebih panjang, tetapi mungkin yang Anda butuhkan untuk grafik. Dengan begitu, ketika Anda memperbarui kode Anda dan istirahat tes, Anda harus secara manual memeriksa gambar jika kegagalan itu nyata, atau Anda meningkatkan kode rendering grafik untuk menghasilkan grafik yang lebih cantik dan perlu memperbarui tangkapan layar.

Jika Anda menggunakan Swing, FEST-Swing berguna untuk menggerakkan GUI Anda dan menguji pernyataan. Itu membuatnya cukup mudah untuk menguji hal-hal seperti "jika saya mengklik tombol A, dialog B harus ditampilkan" atau "jika saya memilih opsi 2 dari drop-down, semua kotak centang harus dipilih" .

Skenario grafik yang Anda sebutkan tidak mudah untuk diuji. Sangat mudah untuk mendapatkan cakupan kode untuk komponen GUI hanya dengan membuat dan menampilkannya (dan mungkin membuatnya dengan FEST). Namun, membuat pernyataan yang bermakna adalah bagian yang sulit (dan cakupan kode tanpa pernyataan yang berarti adalah latihan penipuan diri). Bagaimana Anda menguji bahwa grafik tidak dibuat terbalik, atau terlalu kecil?

Saya pikir Anda hanya harus menerima bahwa beberapa aspek GUI tidak dapat diuji secara efektif dengan tes unit otomatis dan Anda harus mengujinya dengan cara lain.

Bukan tugas Anda untuk menguji perpustakaan GUI. Jadi, Anda dapat menghindari tanggung jawab untuk memeriksa apa yang sebenarnya digambar di layar dan memeriksa properti widget, memercayai perpustakaan bahwa mereka secara akurat mewakili apa yang digambar.