(Mengapa) apakah penting bahwa unit test tidak menguji dependensi?

Saya memahami nilai pengujian otomatis dan menggunakannya di mana pun masalahnya cukup ditentukan sehingga saya bisa menghasilkan kasus pengujian yang baik. Namun, saya perhatikan bahwa beberapa orang di sini dan di StackOverflow menekankan pengujian hanya pada satu unit, bukan ketergantungannya. Di sini saya gagal melihat manfaatnya.

Mengolok-olok / mematikan untuk menghindari ketergantungan pengujian menambah kerumitan pada tes. Ini menambahkan persyaratan fleksibilitas / decoupling buatan ke kode produksi Anda untuk mendukung mengejek. (Saya tidak setuju dengan siapa pun yang mengatakan ini mempromosikan desain yang baik. Menulis kode tambahan, memperkenalkan hal-hal seperti kerangka kerja injeksi ketergantungan, atau menambahkan kompleksitas pada basis kode Anda untuk membuat hal-hal lebih fleksibel / pluggable / extensible / dipisahkan dengan tanpa menggunakan kasus nyata adalah overengineering, tidak desain yang bagus.)

Kedua, menguji dependensi berarti bahwa kode tingkat rendah kritis yang digunakan di mana-mana diuji dengan input selain dari orang yang menulis tes itu secara eksplisit memikirkannya. Saya telah menemukan banyak bug dalam fungsionalitas tingkat rendah dengan menjalankan tes unit pada fungsionalitas tingkat tinggi tanpa mengejek fungsionalitas tingkat rendah yang menjadi sandarannya. Idealnya ini ditemukan oleh unit test untuk fungsionalitas tingkat rendah, tetapi kasus yang terlewat selalu terjadi.

Apa sisi lain dari ini? Apakah benar-benar penting bahwa unit test tidak juga menguji dependensinya? Jika demikian, mengapa?

Sunting: Saya dapat memahami nilai mengejek dependensi eksternal seperti database, jaringan, layanan web, dll. (Terima kasih kepada Anna Lear karena memotivasi saya untuk mengklarifikasi ini.) Saya merujuk pada dependensi internal , yaitu kelas lain, fungsi statis, dll. yang tidak memiliki dependensi eksternal langsung.

Ini masalah definisi. Tes dengan dependensi adalah tes integrasi, bukan tes unit. Anda juga harus memiliki suite tes integrasi. Perbedaannya adalah bahwa suite pengujian integrasi dapat dijalankan dalam kerangka pengujian yang berbeda dan mungkin bukan sebagai bagian dari pembuatan karena membutuhkan waktu lebih lama.

Untuk produk kami: Unit test kami dijalankan dengan setiap build, membutuhkan beberapa detik. Subset dari tes integrasi kami berjalan dengan masing-masing check-in, membutuhkan waktu 10 menit. Suite integrasi penuh kami dijalankan setiap malam, membutuhkan waktu 4 jam.

Pengujian dengan semua dependensi yang ada masih penting, tetapi lebih pada ranah pengujian integrasi seperti yang dikatakan Jeffrey Faust.

Salah satu aspek terpenting dari unit testing adalah membuat tes Anda dapat dipercaya. Jika Anda tidak percaya bahwa tes kelulusan benar-benar berarti semuanya baik dan bahwa tes gagal benar-benar berarti masalah dalam kode produksi, tes Anda hampir tidak berguna seperti semula.

Agar tes Anda dapat dipercaya, Anda harus melakukan beberapa hal, tetapi saya akan fokus hanya pada satu untuk jawaban ini. Anda harus memastikan mereka mudah dijalankan, sehingga semua pengembang dapat dengan mudah menjalankannya sebelum memeriksa kode. "Mudah dijalankan" berarti tes Anda berjalan cepat dan tidak ada konfigurasi atau pengaturan yang luas yang diperlukan untuk membuatnya berjalan. Idealnya, siapa pun harus dapat melihat versi terbaru dari kode, menjalankan tes segera, dan melihatnya lulus.

Mengabstraksi ketergantungan pada hal-hal lain (sistem file, database, layanan web, dll.) Memungkinkan Anda untuk menghindari memerlukan konfigurasi dan membuat Anda dan pengembang lainnya kurang rentan terhadap situasi di mana Anda tergoda untuk mengatakan "Oh, tes gagal karena saya tidak "Saya sudah menyiapkan jaringan berbagi. Oh well. Saya akan jalankan nanti."

Jika Anda ingin menguji apa yang Anda lakukan dengan beberapa data, unit Anda menguji kode logika bisnis itu seharusnya tidak peduli bagaimana Anda mendapatkan data itu. Mampu menguji logika inti aplikasi Anda tanpa bergantung pada hal-hal yang mendukung seperti database itu mengagumkan. Jika Anda tidak melakukannya, Anda kehilangan.

PS Saya harus menambahkan bahwa itu pasti mungkin untuk overengineer atas nama testability. Menguji mengemudi aplikasi Anda membantu mengurangi itu. Namun bagaimanapun juga, implementasi pendekatan yang buruk tidak membuat pendekatan tersebut kurang valid. Apa pun dapat disalahgunakan dan dilakukan secara berlebihan jika seseorang tidak terus bertanya "mengapa saya melakukan ini?" saat berkembang.

public class MyClass 
{
    private SomeClass someClass;
    public MyClass()
    {
        someClass = new SomeClass();
    }

    // use someClass in some way
}

Saya biasanya tidak peduli bagaimana SomeClassdibuat. Saya hanya ingin menggunakannya. Jika SomeClass berubah dan sekarang memerlukan parameter untuk konstruktor ... itu bukan masalah saya. Saya tidak perlu mengubah MyClass untuk mengakomodasi itu.

Sekarang, itu hanya menyentuh pada bagian desain. Sejauh menyangkut tes unit, saya juga ingin melindungi diri dari kelas lain. Jika saya menguji MyClass, saya suka mengetahui fakta bahwa tidak ada dependensi eksternal, bahwa SomeClass pada suatu titik tidak memperkenalkan koneksi database atau beberapa tautan eksternal lainnya.

Tetapi masalah yang lebih besar adalah bahwa saya juga tahu bahwa beberapa hasil metode saya bergantung pada output dari beberapa metode pada SomeClass. Tanpa mengejek / mematikan SomeClass, saya mungkin tidak memiliki cara untuk memvariasikan input yang diminta. Jika saya beruntung, saya mungkin bisa menyusun lingkungan saya di dalam tes sedemikian rupa sehingga akan memicu respons yang tepat dari SomeClass, tetapi dengan cara itu memperkenalkan kompleksitas ke dalam tes saya dan membuatnya rapuh.

Menulis ulang MyClass untuk menerima turunan SomeClass di konstruktor memungkinkan saya untuk membuat turunan palsu dari SomeClass yang mengembalikan nilai yang saya inginkan (baik melalui kerangka kerja mengejek atau dengan tiruan manual). Saya biasanya tidak harus memperkenalkan antarmuka dalam hal ini. Apakah melakukannya atau tidak dalam banyak hal merupakan pilihan pribadi yang mungkin ditentukan oleh bahasa pilihan Anda (mis. Antarmuka lebih mungkin dalam C #, tetapi Anda pasti tidak akan membutuhkannya di Ruby).

Selain masalah unit vs integrasi, pertimbangkan hal berikut.

Widget Kelas memiliki dependensi pada kelas Thingamajig dan WhatsIt.

Tes unit untuk Widget gagal.

Di kelas mana masalahnya?

Jika Anda menjawab "jalankan debugger" atau "baca kode sampai saya menemukannya", Anda memahami pentingnya menguji hanya unit, bukan dependensi.

Bayangkan pemrograman itu seperti memasak. Kemudian pengujian unit sama dengan memastikan bahan-bahan Anda segar, enak, dll. Sedangkan pengujian integrasi seperti memastikan makanan Anda lezat.

Pada akhirnya, memastikan bahwa makanan Anda lezat (atau bahwa sistem Anda berfungsi) adalah hal yang paling penting, tujuan akhir. Tetapi jika bahan Anda, maksud saya, unit, bekerja, Anda akan memiliki cara yang lebih murah untuk mengetahuinya.

Memang, jika Anda dapat menjamin bahwa unit / metode Anda berfungsi, Anda cenderung memiliki sistem yang berfungsi. Saya menekankan "lebih mungkin", bukan "pasti". Anda masih memerlukan tes integrasi, sama seperti Anda masih membutuhkan seseorang untuk mencicipi makanan yang Anda masak dan memberi tahu Anda bahwa produk akhirnya baik. Anda akan lebih mudah tiba di sana dengan bahan-bahan segar, itu saja.

Unit pengujian dengan mengisolasi mereka sepenuhnya akan memungkinkan untuk menguji SEMUA kemungkinan variasi data dan situasi unit ini dapat diajukan. Karena terisolasi dari yang lain, Anda dapat mengabaikan variasi yang tidak memiliki efek langsung pada unit yang akan diuji. ini pada gilirannya akan sangat mengurangi kerumitan tes.

Pengujian dengan berbagai tingkat dependensi terintegrasi akan memungkinkan Anda untuk menguji skenario tertentu yang mungkin belum diuji dalam unit test.

Keduanya penting. Hanya dengan melakukan pengujian unit, Anda akan selalu mengalami kesalahan yang lebih rumit saat mengintegrasikan komponen. Hanya melakukan pengujian integrasi berarti Anda menguji suatu sistem tanpa keyakinan bahwa bagian-bagian individu dari mesin belum diuji. Untuk berpikir Anda dapat mencapai tes lengkap yang lebih baik hanya dengan melakukan pengujian integrasi hampir mustahil karena semakin banyak komponen yang Anda tambahkan jumlah kombinasi entri tumbuh SANGAT cepat (pikirkan faktorial) dan membuat tes dengan cakupan yang memadai menjadi sangat cepat menjadi sangat mustahil.

Jadi singkatnya, tiga level "unit testing" yang biasanya saya gunakan di hampir semua proyek saya:

• Tes unit, diisolasi dengan dependensi yang diejek atau di-stub untuk menguji komponen tunggal. Idealnya orang akan mencoba cakupan lengkap.
• Tes integrasi untuk menguji kesalahan yang lebih halus. Pemeriksaan spot yang dibuat dengan hati-hati yang akan menunjukkan batas kasus dan kondisi umum. Cakupan lengkap seringkali tidak memungkinkan, upaya terfokus pada apa yang akan membuat sistem gagal.
• Pengujian spesifikasi untuk menyuntikkan berbagai data kehidupan nyata dalam sistem, instrumen data (jika mungkin) dan mengamati output untuk memastikan itu sesuai dengan spesifikasi dan aturan bisnis.

Injeksi ketergantungan adalah salah satu cara yang sangat efisien untuk mencapai ini karena memungkinkan untuk mengisolasi komponen untuk unit test dengan sangat mudah tanpa menambah kompleksitas pada sistem. Skenario bisnis Anda mungkin tidak menjamin penggunaan mekanisme injeksi tetapi skenario pengujian Anda akan melakukannya. Ini bagi saya sudah cukup untuk membuatnya sangat diperlukan. Anda dapat menggunakannya juga untuk menguji berbagai tingkat abstraksi secara mandiri melalui pengujian integrasi parsial.

Apa sisi lain dari ini? Apakah benar-benar penting bahwa unit test tidak juga menguji dependensinya? Jika demikian, mengapa?

Satuan. Berarti tunggal.

Menguji 2 hal berarti Anda memiliki dua hal dan semua dependensi fungsional.

Jika Anda menambahkan hal ke-3, Anda meningkatkan dependensi fungsional dalam tes di luar linear. Interkoneksi di antara hal-hal tumbuh lebih cepat daripada jumlah hal.

Ada n (n-1) / 2 ketergantungan potensial antara n item yang sedang diuji.

Itulah alasan utamanya.

Kesederhanaan memiliki nilai.

Ingat bagaimana Anda pertama kali belajar melakukan rekursi? Prof saya berkata, "Asumsikan Anda memiliki metode yang melakukan x" (misalnya, memecahkan fibbonacci untuk x apa pun). "Untuk menyelesaikan x Anda harus memanggil metode itu untuk x-1 dan x-2". Dalam hal yang sama, mematikan dependensi memungkinkan Anda berpura-pura ada dan menguji apakah unit saat ini melakukan apa yang seharusnya dilakukan. Asumsinya tentu saja bahwa Anda menguji dependensi secara ketat.

Ini pada dasarnya adalah SRP di tempat kerja. Berfokus pada satu tanggung jawab tunggal bahkan untuk pengujian Anda, menghilangkan jumlah juggling mental yang harus Anda lakukan.

(Ini adalah jawaban kecil. Terima kasih @TimWilliscroft untuk petunjuknya.)

Kesalahan lebih mudah untuk dilokalisasi jika:

• Baik unit yang diuji dan masing-masing dependensinya diuji secara independen.
• Setiap tes gagal jika dan hanya jika ada kesalahan dalam kode yang dicakup oleh tes.

Ini bekerja dengan baik di atas kertas. Namun, seperti yang diilustrasikan dalam uraian OP (dependensi bersifat buggy), jika dependensi tidak diuji, akan sulit untuk menentukan lokasi kesalahan.

Banyak jawaban bagus. Saya juga menambahkan beberapa poin lain:

Pengujian unit juga memungkinkan Anda untuk menguji kode Anda ketika dependensi Anda tidak ada . Misalnya Anda, atau tim Anda, belum menulis lapisan lain, atau mungkin Anda sedang menunggu di antarmuka yang disampaikan oleh perusahaan lain.

Tes unit juga berarti bahwa Anda tidak harus memiliki lingkungan penuh pada mesin dev Anda (mis. Database, server web, dll). Saya kuat akan merekomendasikan bahwa semua pengembang melakukan memiliki lingkungan seperti itu, namun ditebang itu, dalam rangka untuk bug repro dll Namun, jika karena alasan itu tidak mungkin untuk meniru lingkungan produksi maka unit testing setidaknya memberikan yu beberapa tingkat kepercayaan pada kode Anda sebelum masuk ke sistem pengujian yang lebih besar.

Tentang aspek desain: Saya percaya bahwa proyek kecil pun mendapat manfaat dari membuat kode dapat diuji. Anda tidak perlu harus memperkenalkan sesuatu seperti Guice (kelas pabrik sederhana akan sering melakukannya), tetapi memisahkan proses konstruksi dari hasil logika pemrograman dalam

• dengan jelas mendokumentasikan dependensi setiap kelas melalui antarmuka itu (sangat membantu bagi orang-orang yang baru dalam tim)
• kelas-kelas menjadi lebih jelas dan lebih mudah untuk dipertahankan (setelah Anda menempatkan pembuatan objek grafik jelek ke kelas terpisah)
• kopling longgar (membuat perubahan lebih mudah)

Uh ... ada poin bagus pada pengujian unit dan integrasi yang ditulis dalam jawaban ini di sini!

Saya melewatkan pandangan terkait biaya dan praktis di sini. Yang mengatakan saya melihat dengan jelas manfaat dari tes unit atom / sangat terisolasi (mungkin sangat independen satu sama lain dan dengan opsi untuk menjalankannya secara paralel dan tanpa dependensi, seperti database, filesystem dll.) Dan tes integrasi (tingkat lebih tinggi), tapi ... itu juga masalah biaya (waktu, uang, ...) dan risiko .

Jadi ada faktor-faktor lain, yang jauh lebih penting (seperti "apa yang harus diuji" ) sebelum Anda memikirkan "cara menguji" dari pengalaman saya ...

Apakah pelanggan saya (secara tidak langsung) membayar biaya penulisan dan perawatan tambahan? Apakah pendekatan yang lebih didorong oleh tes (tulis tes terlebih dahulu sebelum Anda menulis kode) benar-benar hemat biaya di lingkungan saya (risiko kegagalan kode / analisis biaya, orang, spesifikasi desain, pengaturan lingkungan pengujian)? Kode selalu bermasalah, tetapi bisakah biaya lebih efektif untuk memindahkan pengujian ke penggunaan produksi (dalam kasus terburuk!)?

Ini juga sangat tergantung pada apa kualitas kode Anda (standar) atau kerangka kerja, IDE, prinsip-prinsip desain dll. Anda dan tim Anda ikuti dan seberapa berpengalaman mereka. Sebuah kode yang ditulis dengan baik, mudah dimengerti, cukup baik didokumentasikan (idealnya mendokumentasikan diri), modular, ... memperkenalkan bug yang kemungkinan lebih sedikit daripada yang sebaliknya. Jadi "kebutuhan" nyata, tekanan atau biaya pemeliharaan / perbaikan bug / risiko keseluruhan untuk pengujian ekstensif mungkin tidak tinggi.

Mari kita bawa ke ekstrim di mana rekan kerja di tim saya menyarankan, kita harus mencoba untuk menguji unit kode lapisan model Java EE murni kami dengan cakupan 100% yang diinginkan untuk semua kelas di dalam dan mengejek basis data. Atau manajer yang ingin pengujian integrasi dicakup dengan 100% dari semua kasus penggunaan dunia nyata dan alur kerja web ui karena kami tidak ingin mengambil risiko kasus penggunaan apa pun gagal. Tetapi kami memiliki anggaran yang ketat sekitar 1 juta euro, beberapa rencana yang ketat untuk mengkodekan semuanya. Lingkungan pelanggan, di mana bug aplikasi potensial tidak akan menjadi bahaya yang sangat besar bagi manusia atau perusahaan. Aplikasi kami akan diuji secara internal dengan (beberapa) tes unit penting, tes integrasi, tes pelanggan utama dengan rencana uji yang dirancang, fase uji dll. Kami tidak mengembangkan aplikasi untuk beberapa pabrik nuklir atau produksi farmasi!

Saya sendiri mencoba menulis tes jika memungkinkan dan mengembangkan sementara unit menguji kode saya. Tapi saya sering melakukannya dari pendekatan top-down (pengujian integrasi) dan mencoba untuk menemukan titik yang baik, di mana untuk membuat "pemotongan layer aplikasi" untuk tes penting (sering dalam model-layer). (karena sering banyak tentang "lapisan")

Lebih lanjut, unit dan kode uji integrasi tidak datang tanpa dampak negatif pada waktu, uang, pemeliharaan, pengkodean, dll. Ini keren dan harus diterapkan, tetapi dengan hati-hati dan mempertimbangkan implikasi ketika memulai atau setelah 5 tahun dari banyak tes yang dikembangkan kode.

Jadi saya akan mengatakan itu sangat tergantung pada kepercayaan dan biaya / risiko / evaluasi manfaat ... seperti dalam kehidupan nyata di mana Anda tidak bisa dan tidak ingin berlarian dengan banyak atau 100% mekanisme keamanan.

Anak itu bisa dan harus memanjat ke suatu tempat dan mungkin jatuh dan melukai dirinya sendiri. Mobil mungkin berhenti bekerja karena saya mengisi bahan bakar yang salah (input tidak valid :)). Roti bakar dapat terbakar jika tombol waktu berhenti bekerja setelah 3 tahun. Tapi saya tidak, tidak pernah, ingin mengemudi di jalan raya dan memegang setir saya yang terlepas di tangan saya :)