Apa itu pengujian unit? [Tutup]

Saya melihat banyak pertanyaan yang menanyakan 'bagaimana' untuk menguji unit dalam bahasa tertentu, tetapi tidak ada pertanyaan yang menanyakan 'apa', 'mengapa', dan 'kapan'.

• Apa itu?
• Apa manfaatnya bagi saya?
• Mengapa saya harus menggunakannya?
• Kapan saya harus menggunakannya (juga kapan tidak)?
• Apa saja jebakan dan kesalahpahaman umum

Pengujian unit, secara umum, menguji bit kode Anda secara terpisah dengan kode uji. Keuntungan langsung yang muncul dalam pikiran adalah:

• Menjalankan tes menjadi otomatis dan dapat diulang
• Anda dapat menguji pada tingkat yang lebih terperinci daripada pengujian titik-dan-klik melalui GUI

Perhatikan bahwa jika kode tes Anda menulis ke file, membuka koneksi database atau melakukan sesuatu melalui jaringan, itu lebih tepat dikategorikan sebagai tes integrasi. Tes integrasi adalah hal yang baik, tetapi jangan bingung dengan tes unit. Kode tes unit harus pendek, manis dan cepat dijalankan.

Cara lain untuk melihat pengujian unit adalah Anda menulis tes terlebih dahulu. Ini dikenal sebagai Test-Driven Development (disingkat TDD). TDD membawa keuntungan tambahan:

• Anda tidak menulis kode "Saya mungkin membutuhkan ini di masa depan" spekulatif - cukup hanya untuk membuat tes lulus
• Kode yang Anda tulis selalu dicakup oleh tes
• Dengan menulis tes terlebih dahulu, Anda terpaksa berpikir tentang bagaimana Anda ingin memanggil kode, yang biasanya meningkatkan desain kode dalam jangka panjang.

Jika Anda tidak melakukan pengujian unit sekarang, saya sarankan Anda memulai. Dapatkan buku yang bagus, praktis setiap buku xUnit akan berhasil karena konsepnya sangat banyak dapat ditransfer di antara mereka.

Kadang-kadang tes unit menulis bisa menyakitkan. Ketika sudah seperti itu, cobalah untuk menemukan seseorang untuk membantu Anda, dan tahan godaan untuk "hanya menulis kode sialan". Pengujian unit sangat mirip dengan mencuci piring. Ini tidak selalu menyenangkan, tetapi membuat dapur metaforis Anda tetap bersih, dan Anda benar-benar ingin itu bersih. :)

Sunting: Satu kesalahpahaman muncul di pikiran, meskipun saya tidak yakin apakah itu sangat umum. Saya pernah mendengar seorang manajer proyek mengatakan bahwa unit test membuat tim menulis semua kode dua kali. Jika terlihat dan terasa seperti itu, yah, Anda salah melakukannya. Tidak hanya menulis tes biasanya mempercepat pengembangan, tetapi juga memberi Anda indikator nyaman "sekarang saya sudah selesai" bahwa Anda tidak akan sebaliknya.

Saya tidak setuju dengan Dan (walaupun pilihan yang lebih baik mungkin tidak menjawab) ... tapi ...

Pengujian unit adalah proses penulisan kode untuk menguji perilaku dan fungsionalitas sistem Anda.

Jelas tes meningkatkan kualitas kode Anda, tetapi itu hanya manfaat yang dangkal dari pengujian unit. Manfaat nyata adalah untuk:

1. Buat lebih mudah untuk mengubah implementasi teknis sambil memastikan Anda tidak mengubah perilaku (refactoring). Kode unit yang diuji dengan benar dapat secara agresif di-refactored / dibersihkan dengan sedikit peluang untuk memecahkan sesuatu tanpa menyadarinya.
2. Berikan kepercayaan diri pengembang saat menambahkan perilaku atau melakukan perbaikan.
3. Dokumentasikan kode Anda
4. Tunjukkan area kode Anda yang tergabung erat. Sulit untuk menyatukan kode uji yang sangat erat
5. Berikan sarana untuk menggunakan API Anda dan cari kesulitan sejak dini
6. Menunjukkan metode dan kelas yang tidak terlalu kohesif

Anda harus menguji unit karena itu kepentingan Anda untuk memberikan produk yang dapat dirawat dan berkualitas kepada klien Anda.

Saya sarankan Anda menggunakannya untuk sistem apa pun, atau bagian dari suatu sistem, yang memodelkan perilaku dunia nyata. Dengan kata lain, ini sangat cocok untuk pengembangan usaha. Saya tidak akan menggunakannya untuk program pembuangan / utilitas. Saya tidak akan menggunakannya untuk bagian dari sistem yang bermasalah untuk diuji (UI adalah contoh umum, tapi itu tidak selalu terjadi)

Jebakan terbesar adalah bahwa pengembang menguji unit terlalu besar, atau mereka menganggap metode sebagai unit. Ini khususnya benar jika Anda tidak memahami Pembalikan Kontrol - dalam hal ini pengujian unit Anda akan selalu berubah menjadi pengujian integrasi ujung-ke-ujung. Tes unit harus menguji perilaku individu - dan sebagian besar metode memiliki banyak perilaku.

Kesalahpahaman terbesar adalah bahwa programmer tidak boleh menguji. Hanya programmer yang buruk atau malas yang percaya itu. Haruskah orang yang membangun atap Anda tidak mengujinya? Haruskah dokter mengganti katup jantung tidak menguji katup baru? Hanya seorang programmer yang dapat menguji bahwa kodenya melakukan apa yang ia inginkan (QA dapat menguji kasus tepi - bagaimana kode berperilaku ketika diperintahkan untuk melakukan hal-hal yang tidak diinginkan oleh programmer, dan klien dapat melakukan tes penerimaan - apakah kode melakukan apa yang dibayar klien untuk melakukannya)

Perbedaan utama dari pengujian unit, berlawanan dengan "hanya membuka proyek baru dan menguji kode khusus ini" adalah bahwa itu otomatis , sehingga dapat diulang .

Jika Anda menguji kode secara manual, ini dapat meyakinkan Anda bahwa kode tersebut berfungsi dengan baik - dalam kondisi saat ini . Tetapi bagaimana dengan seminggu kemudian, ketika Anda membuat sedikit modifikasi di dalamnya? Apakah Anda bersedia untuk menguji ulang lagi dengan tangan setiap kali ada perubahan dalam kode Anda? Kemungkinan besar tidak :-(

Tetapi jika Anda dapat menjalankan tes Anda kapan saja, dengan satu klik, dengan cara yang persis sama, dalam beberapa detik , maka mereka akan segera menunjukkan kepada Anda setiap kali ada masalah. Dan jika Anda juga mengintegrasikan tes unit ke dalam proses pembuatan otomatis Anda, mereka akan mengingatkan Anda untuk bug bahkan dalam kasus di mana perubahan yang tampaknya tidak berhubungan sama sekali memecahkan sesuatu di bagian yang jauh dari basis kode - ketika itu bahkan tidak akan terjadi pada Anda bahwa ada kebutuhan untuk menguji ulang fungsionalitas tertentu.

Ini adalah keunggulan utama dari pengujian unit dibandingkan pengujian tangan. Tapi tunggu, masih ada lagi:

• unit test memperpendek loop umpan balik pengembangan secara dramatis: dengan departemen pengujian yang terpisah mungkin perlu berminggu-minggu bagi Anda untuk mengetahui bahwa ada bug dalam kode Anda, pada saat itu Anda sudah lupa banyak konteks, sehingga mungkin Anda perlu berjam-jam untuk temukan dan perbaiki bug; OTOH dengan unit test, siklus umpan balik diukur dalam hitungan detik, dan proses perbaikan bug biasanya di sepanjang garis "oh sh * t, saya lupa memeriksa kondisi itu di sini" :-)
• unit test secara efektif mendokumentasikan (pemahaman Anda tentang) perilaku kode Anda
• unit testing memaksa Anda untuk mengevaluasi kembali pilihan desain Anda, yang menghasilkan desain yang lebih sederhana dan lebih bersih

Kerangka kerja pengujian unit, pada gilirannya, memudahkan Anda untuk menulis dan menjalankan tes Anda.

Saya tidak pernah diajarkan pengujian unit di universitas, dan perlu beberapa saat untuk "mendapatkannya". Saya membacanya, pergi "ah, benar, pengujian otomatis, itu bisa keren saya kira", dan kemudian saya lupa.

Butuh sedikit lebih lama sebelum saya benar-benar memahami intinya: Katakanlah Anda sedang mengerjakan sistem besar dan Anda menulis modul kecil. Itu mengkompilasi, Anda menempatkannya melalui langkah-langkahnya, itu bekerja dengan baik, Anda beralih ke tugas berikutnya. Sembilan bulan kemudian dan dua versi kemudian orang lain membuat perubahan pada bagian program yang tampaknya tidak terkait, dan itu merusak modul. Lebih buruk lagi, mereka menguji perubahan mereka, dan kode mereka berfungsi, tetapi mereka tidak menguji modul Anda; sial, mereka bahkan mungkin tidak tahu modul Anda ada .

Dan sekarang Anda punya masalah: kode rusak ada di bagasi dan bahkan tidak ada yang tahu. Kasing terbaik adalah penguji internal menemukannya sebelum Anda kirim, tetapi memperbaiki kode yang terlambat dalam permainan itu mahal. Dan jika tidak ada penguji internal yang menemukannya ... yah, itu bisa menjadi sangat mahal.

Solusinya adalah unit test. Mereka akan menangkap masalah ketika Anda menulis kode - yang baik-baik saja - tetapi Anda bisa melakukannya dengan tangan. Imbalan nyata adalah bahwa mereka akan menangkap masalah sembilan bulan ke depan ketika Anda sekarang bekerja pada proyek yang sama sekali berbeda, tetapi magang musim panas berpikir itu akan terlihat lebih rapi jika parameter-parameter itu dalam urutan abjad - dan kemudian unit test Anda menulis jalan kembali gagal, dan seseorang melempar sesuatu di magang sampai dia mengubah urutan parameter kembali. Itulah "mengapa" dari unit test. :-)

Memilih pro filosofis pengujian unit dan TDD di sini adalah beberapa dari mereka pengamatan "bola lampu" kunci yang mengejutkan saya pada langkah pertama tentatif saya di jalan menuju pencerahan TDD (tidak ada berita asli atau berita) ...

1. TDD TIDAK berarti menulis dua kali jumlah kode. Kode tes biasanya cukup cepat dan tidak menyakitkan untuk ditulis dan merupakan bagian penting dari proses desain Anda dan kritis.

2. TDD membantu Anda menyadari kapan harus berhenti coding! Tes Anda memberi Anda keyakinan bahwa Anda telah melakukan cukup untuk saat ini dan dapat berhenti mengutak-atik dan beralih ke hal berikutnya.

3. Tes dan kode bekerja bersama untuk mencapai kode yang lebih baik. Kode Anda bisa buruk / bermasalah. UJI Anda bisa buruk / bermasalah. Dalam TDD Anda mengandalkan kemungkinan KEDUA buruk / buggy menjadi cukup rendah. Seringkali ini adalah tes yang perlu diperbaiki tetapi itu masih merupakan hasil yang baik.

4. TDD membantu mengkodekan sembelit. Anda tahu perasaan bahwa Anda memiliki begitu banyak hal untuk dilakukan, Anda hampir tidak tahu harus mulai dari mana? Ini hari Jumat sore, jika Anda hanya menunda untuk beberapa jam lagi ... TDD memungkinkan Anda untuk menyempurnakan dengan cepat apa yang menurut Anda perlu Anda lakukan, dan membuat kode Anda bergerak dengan cepat. Juga, seperti tikus lab, saya pikir kita semua merespons lampu hijau besar itu dan bekerja lebih keras untuk melihatnya lagi!

5. Dalam nada yang sama, tipe desainer ini dapat MELIHAT apa yang sedang mereka kerjakan. Mereka dapat berkeliaran untuk istirahat jus / rokok / iphone dan kembali ke monitor yang segera memberi mereka petunjuk visual ke mana mereka harus pergi. TDD memberi kita sesuatu yang serupa. Lebih mudah untuk melihat di mana kita sampai ketika hidup ...

6. Saya pikir itu adalah Fowler yang mengatakan: "Tes tidak sempurna, sering berjalan, jauh lebih baik daripada tes sempurna yang tidak pernah ditulis sama sekali". Saya menafsirkan ini sebagai memberi saya izin untuk menulis tes di mana saya pikir mereka akan sangat berguna bahkan jika sisa cakupan kode saya sangat tidak lengkap.

7. TDD membantu segala macam cara mengejutkan di telepon. Tes unit yang baik dapat membantu mendokumentasikan apa yang seharusnya dilakukan, mereka dapat membantu Anda memigrasi kode dari satu proyek ke proyek lain dan memberi Anda perasaan superioritas yang tidak beralasan atas kolega non-pengujian Anda :)

Presentasi ini adalah pengantar yang sangat baik untuk semua pengujian kebaikan yang diperlukan.

Saya ingin merekomendasikan buku Pola Pengujian xUnit oleh Gerard Meszaros. Ini besar tetapi merupakan sumber yang bagus untuk pengujian unit. Berikut ini tautan ke situs webnya di mana ia membahas dasar-dasar pengujian unit. http://xunitpatterns.com/XUnitBasics.html

Saya menggunakan tes unit untuk menghemat waktu.

Ketika membangun logika bisnis (atau akses data), fungsionalitas pengujian sering kali melibatkan pengetikan barang ke banyak layar yang mungkin atau mungkin belum selesai. Mengotomatiskan tes ini menghemat waktu.

Bagi saya unit test adalah semacam test harness yang dimodulasi. Biasanya ada setidaknya satu tes per fungsi publik. Saya menulis tes tambahan untuk mencakup berbagai perilaku.

Semua kasus khusus yang Anda pikirkan ketika mengembangkan kode dapat direkam dalam kode dalam unit test. Tes unit juga menjadi sumber contoh tentang cara menggunakan kode.

Jauh lebih cepat bagi saya untuk menemukan bahwa kode baru saya memecahkan sesuatu dalam pengujian unit saya kemudian memeriksa kode dan meminta beberapa pengembang front-end menemukan masalah.

Untuk pengujian akses data, saya mencoba menulis tes yang tidak memiliki perubahan atau pembersihan setelahnya.

Tes unit tidak akan dapat menyelesaikan semua persyaratan pengujian. Mereka akan dapat menghemat waktu pengembangan dan menguji bagian inti dari aplikasi.

Ini adalah pendapat saya. Saya akan mengatakan pengujian unit adalah praktik menulis tes perangkat lunak untuk memverifikasi bahwa perangkat lunak Anda yang sebenarnya melakukan apa yang dimaksudkan. Ini dimulai dengan jUnit di dunia Java dan telah menjadi praktik terbaik dalam PHP juga dengan SimpleTest dan phpUnit . Ini adalah praktik inti dari Pemrograman Ekstrim dan membantu Anda memastikan bahwa perangkat lunak Anda masih berfungsi sebagaimana dimaksud setelah diedit. Jika Anda memiliki cakupan tes yang cukup, Anda dapat melakukan refactoring besar, memperbaiki bug atau menambahkan fitur dengan cepat tanpa rasa takut akan menimbulkan masalah lain.

Ini paling efektif ketika semua unit test dapat dijalankan secara otomatis.

Pengujian unit umumnya terkait dengan pengembangan OO. Ide dasarnya adalah membuat skrip yang mengatur lingkungan untuk kode Anda dan kemudian menggunakannya; Anda menulis pernyataan, tentukan keluaran yang diinginkan yang harus Anda terima dan kemudian jalankan skrip pengujian Anda menggunakan kerangka kerja seperti yang disebutkan di atas.

Kerangka kerja akan menjalankan semua tes terhadap kode Anda dan kemudian melaporkan kembali keberhasilan atau kegagalan setiap tes. phpUnit dijalankan dari baris perintah Linux secara default, meskipun ada antarmuka HTTP yang tersedia untuknya. SimpleTest bersifat berbasis web dan jauh lebih mudah untuk dibangun dan dijalankan, IMO. Dalam kombinasi dengan xDebug, phpUnit dapat memberi Anda statistik otomatis untuk cakupan kode yang beberapa orang merasa sangat berguna.

Beberapa tim menulis kait dari repositori subversi mereka sehingga unit test dijalankan secara otomatis setiap kali Anda melakukan perubahan.

Ini praktik yang baik untuk menjaga unit test Anda dalam repositori yang sama dengan aplikasi Anda.

Pustaka seperti NUnit , xUnit atau JUnit hanya wajib jika Anda ingin mengembangkan proyek Anda menggunakan pendekatan TDD yang dipopulerkan oleh Kent Beck:

Anda dapat membaca Pengantar Pengembangan yang Didorong oleh Tes (TDD) atau buku Kent Beck yang berjudul Pengembangan yang Didorong: Dengan Contoh .

Kemudian, jika Anda ingin memastikan tes Anda mencakup bagian "baik" dari kode Anda, Anda dapat menggunakan perangkat lunak seperti NCover , JCover , PartCover atau apa pun. Mereka akan memberi tahu Anda persentase cakupan kode Anda. Tergantung pada seberapa banyak Anda mahir di TDD, Anda akan tahu jika Anda sudah cukup mempraktikkannya :)

Pengujian unit adalah pengujian unit kode (mis. Fungsi tunggal) tanpa memerlukan infrastruktur yang diandalkan oleh unit kode tersebut. yaitu mengujinya secara terpisah.

Misalnya, jika fungsi yang Anda uji menghubungkan ke database dan melakukan pembaruan, dalam tes unit Anda mungkin tidak ingin melakukan pembaruan itu. Anda akan melakukannya jika itu adalah tes integrasi tetapi dalam kasus ini tidak.

Jadi unit test akan menjalankan fungsionalitas yang terlampir dalam "fungsi" yang Anda uji tanpa efek samping dari pembaruan basis data.

Katakanlah fungsi Anda mengambil beberapa angka dari database dan kemudian melakukan perhitungan standar deviasi. Apa yang ingin kamu coba di sini? Bahwa standar deviasi dihitung dengan benar atau data dikembalikan dari database?

Dalam tes unit Anda hanya ingin menguji bahwa standar deviasi dihitung dengan benar. Dalam tes integrasi Anda ingin menguji perhitungan standar deviasi dan pengambilan basis data.

Pengujian unit adalah tentang penulisan kode yang menguji kode aplikasi Anda.

Bagian Unit dari nama adalah tentang maksud untuk menguji unit kode kecil (satu metode misalnya) pada suatu waktu.

xUnit ada untuk membantu dengan pengujian ini - mereka adalah kerangka kerja yang membantu dengan ini. Bagian dari itu adalah pelari ujian otomatis yang memberi tahu Anda apa yang gagal dan yang lulus uji.

Mereka juga memiliki fasilitas untuk mengatur kode umum yang Anda butuhkan dalam setiap tes sebelum tangan dan merobohkannya ketika semua tes selesai.

Anda dapat melakukan tes untuk memeriksa bahwa pengecualian yang diharapkan telah dilemparkan, tanpa harus menulis keseluruhan coba tangkap blok sendiri.

Saya pikir poin yang Anda tidak mengerti adalah bahwa kerangka pengujian unit seperti NUnit (dan sejenisnya) akan membantu Anda dalam mengotomatisasi tes kecil hingga menengah. Biasanya Anda dapat menjalankan tes dalam GUI ( misalnya NUnit , misalnya) dengan hanya mengklik tombol dan kemudian - semoga - lihat bilah kemajuan tetap hijau. Jika berubah merah, kerangka kerja menunjukkan tes mana yang gagal dan apa yang salah. Dalam tes unit normal, Anda sering menggunakan pernyataan, misalnya Assert.AreEqual(expectedValue, actualValue, "some description")- jadi jika kedua nilai tersebut tidak sama, Anda akan melihat kesalahan yang mengatakan "beberapa deskripsi: yang diharapkan <Ekspektasi> tetapi <actualValue>".

Jadi sebagai pengujian unit kesimpulan akan membuat pengujian lebih cepat dan jauh lebih nyaman bagi pengembang. Anda dapat menjalankan semua pengujian unit sebelum melakukan kode baru sehingga Anda tidak merusak proses pembuatan pengembang lain pada proyek yang sama.

Gunakan Testivus . Yang perlu Anda ketahui ada di sana :)

Pengujian unit adalah praktik untuk memastikan bahwa fungsi atau modul yang akan Anda implementasikan akan berperilaku seperti yang diharapkan (persyaratan) dan juga untuk memastikan bagaimana berperilaku dalam skenario seperti kondisi batas, dan input yang tidak valid.

xUnit , NUnit , mbUnit , dll. adalah alat yang membantu Anda dalam menulis tes.

Pengembangan Test Driven telah semacam diambil alih istilah Uji Unit. Sebagai penghitung waktu lama, saya akan menyebutkan definisi yang lebih umum.

Unit Test juga berarti menguji satu komponen dalam sistem yang lebih besar. Komponen tunggal ini bisa berupa dll, exe, class library, dll. Bahkan bisa berupa sistem tunggal dalam aplikasi multi-sistem. Jadi akhirnya Unit Test akhirnya menjadi pengujian apa pun yang Anda ingin sebut sebagai bagian dari sistem yang lebih besar.

Anda kemudian akan naik ke pengujian sistem atau terintegrasi dengan menguji bagaimana semua komponen bekerja bersama.

Pertama-tama, apakah berbicara tentang pengujian Unit atau segala jenis pengujian otomatis lainnya (Integrasi, Muatan, pengujian UI, dll.), Perbedaan utama dari apa yang Anda sarankan adalah otomatis, berulang dan tidak memerlukan sumber daya manusia untuk dikonsumsi (= tidak ada yang harus melakukan tes, mereka biasanya dijalankan dengan menekan tombol).

Saya pergi ke presentasi tentang pengujian unit di FoxForward 2007 dan diberitahu untuk tidak menguji unit apa pun yang bekerja dengan data. Lagi pula, jika Anda menguji pada data langsung, hasilnya tidak dapat diprediksi, dan jika Anda tidak menguji pada data langsung, Anda sebenarnya tidak menguji kode yang Anda tulis. Sayangnya, itulah kebanyakan pengkodean yang saya lakukan hari ini. :-)

Saya melakukan pemotretan di TDD baru-baru ini ketika saya sedang menulis rutin untuk menyimpan dan mengembalikan pengaturan. Pertama, saya memverifikasi bahwa saya bisa membuat objek penyimpanan. Kemudian, itu memiliki metode yang perlu saya panggil. Lalu, aku bisa menyebutnya begitu. Lalu, saya bisa memberikan parameter itu. Kemudian, saya bisa memberikannya parameter khusus. Dan seterusnya, sampai saya akhirnya memverifikasi bahwa itu akan menyimpan pengaturan yang ditentukan, izinkan saya untuk mengubahnya, dan kemudian mengembalikannya, untuk beberapa sintaks yang berbeda.

Aku tidak sampai pada akhirnya, karena aku butuh-rutin-sekarang-sial, tapi itu latihan yang bagus.

Apa yang Anda lakukan jika Anda diberi setumpuk omong kosong dan sepertinya Anda terjebak dalam kondisi pembersihan terus-menerus yang Anda tahu dengan penambahan fitur atau kode baru dapat merusak set saat ini karena perangkat lunak saat ini seperti rumah dari kartu-kartu?

Bagaimana kita bisa melakukan pengujian unit?

Anda memulai dari yang kecil. Proyek yang baru saya masuki tidak memiliki unit testing sampai beberapa bulan yang lalu. Ketika cakupannya serendah itu, kami hanya akan memilih file yang tidak memiliki jangkauan dan klik "tambahkan tes".

Saat ini kami sudah mencapai lebih dari 40%, dan kami telah berhasil memetik sebagian besar dari buah-buahan yang menggantung rendah.

(Bagian terbaiknya adalah bahwa bahkan pada tingkat cakupan yang rendah ini, kami sudah mengalami banyak contoh kode melakukan hal yang salah, dan pengujian menangkapnya. Itu adalah motivator besar untuk mendorong orang untuk menambahkan lebih banyak pengujian.)

Ini menjawab mengapa Anda harus melakukan pengujian unit.

3 video di bawah ini mencakup pengujian unit dalam javascript tetapi prinsip-prinsip umum berlaku di sebagian besar bahasa.

Unit Testing: Menit Sekarang Akan Hemat Jam Kemudian - Eric Mann - https://www.youtube.com/watch?v=_UmmaPe8Bzc

JS Unit Testing (sangat bagus) - https://www.youtube.com/watch?v=-IYqgx8JxlU

Menulis JavaScript yang Dapat Diuji - https://www.youtube.com/watch?v=OzjogCFO4Zo

Sekarang saya baru belajar tentang subjek jadi saya mungkin tidak 100% benar dan ada lebih dari itu daripada apa yang saya jelaskan di sini tapi pemahaman dasar saya tentang pengujian unit adalah bahwa Anda menulis beberapa kode pengujian (yang disimpan terpisah dari Anda kode utama) yang memanggil suatu fungsi dalam kode utama Anda dengan input (argumen) yang diperlukan oleh fungsi tersebut dan kemudian memeriksa apakah kode tersebut mengembalikan nilai pengembalian yang valid. Jika tidak mendapatkan kembali nilai yang valid, kerangka pengujian unit yang Anda gunakan untuk menjalankan tes menunjukkan lampu hijau (semua baik) jika nilai tidak valid Anda mendapatkan lampu merah dan Anda kemudian dapat memperbaiki masalah langsung sebelum Anda lepaskan kode baru ke produksi, tanpa pengujian Anda mungkin sebenarnya tidak menangkap kesalahan.

Jadi Anda menulis tes untuk Anda kode saat ini dan membuat kode sehingga lulus tes. Berbulan-bulan kemudian, Anda atau orang lain perlu memodifikasi fungsi dalam kode utama Anda, karena sebelumnya Anda sudah menulis kode pengujian untuk fungsi tersebut, Anda sekarang dapat menjalankannya lagi dan pengujiannya mungkin gagal karena pembuat kode memperkenalkan kesalahan logika pada fungsi tersebut atau mengembalikan sesuatu sepenuhnya. berbeda dari apa fungsi yang seharusnya dikembalikan. Sekali lagi tanpa tes di tempat kesalahan itu mungkin sulit untuk dilacak karena dapat mempengaruhi kode lain juga dan akan luput dari perhatian.

Juga fakta bahwa Anda memiliki program komputer yang menjalankan kode Anda dan mengujinya alih-alih Anda melakukannya secara manual di halaman browser demi halaman menghemat waktu (pengujian unit untuk javascript). Katakanlah Anda memodifikasi fungsi yang digunakan oleh beberapa skrip pada halaman web dan berfungsi dengan baik dan baik untuk tujuan yang baru. Tetapi, katakan juga demi argumen bahwa ada fungsi lain yang Anda miliki di tempat lain dalam kode Anda yang bergantung pada fungsi yang baru dimodifikasi agar dapat berfungsi dengan baik. Fungsi dependen ini sekarang dapat berhenti bekerja karena perubahan yang Anda buat pada fungsi pertama, namun tanpa tes di tempat yang dijalankan secara otomatis oleh komputer Anda, Anda tidak akan melihat bahwa ada masalah dengan fungsi itu sampai benar-benar dieksekusi dan kamu'

Untuk mengulangi, memiliki tes yang dijalankan saat mengembangkan aplikasi Anda akan menangkap masalah seperti ini saat Anda sedang coding. Tidak memiliki tes di tempat Anda harus secara manual melalui seluruh aplikasi Anda dan bahkan kemudian itu bisa sulit untuk menemukan bug, secara naif Anda mengirimkannya ke dalam produksi dan setelah beberapa saat pengguna yang baik mengirimi Anda laporan bug (yang tidak akan sebagus pesan kesalahan Anda dalam kerangka pengujian).

Ini cukup membingungkan ketika Anda pertama kali mendengar subjek dan Anda berpikir, apakah saya belum menguji kode saya? Dan kode yang Anda tulis berfungsi seperti seharusnya, "mengapa saya perlu kerangka kerja lain?" ... Ya Anda sudah menguji kode Anda tetapi komputer lebih baik dalam melakukannya. Anda hanya perlu menulis tes yang cukup baik untuk fungsi / unit kode sekali dan sisanya diurus untuk Anda oleh cpu perkasa alih-alih Anda harus memeriksa secara manual bahwa semua kode Anda masih berfungsi ketika Anda membuat perubahan ke kode Anda.

Selain itu, Anda tidak perlu menguji unit kode Anda jika Anda tidak ingin tetapi itu terbayar karena proyek / basis kode Anda mulai tumbuh lebih besar karena kemungkinan memperkenalkan bug meningkat.

Pengujian unit dan TDD secara umum memungkinkan Anda memiliki siklus umpan balik yang lebih pendek tentang perangkat lunak yang Anda tulis. Alih-alih memiliki fase uji besar di akhir implementasi, Anda secara bertahap menguji semua yang Anda tulis. Ini sangat meningkatkan kualitas kode, seperti yang Anda lihat segera, di mana Anda mungkin memiliki bug.