Bikin unit testnya saja dulu, biar coveragenya kita sesuai standar.

Jangaaan…, refactoring dulu saja, unit test bisa belakangan.

– The dilemma’s


Pendahuluan

2 hal penting yang mesti menjadi kebiasaan baik bagi seorang Software Engineering adalah :

  • Membuat unit test terhadap code yang sedang dibuat.
  • Melakukan refactoring / perbaikan / rewrite code terhadap code yang ada.

Walaupun banyak juga yang tidak melakukan hal-hal diatas, dengan banyak alasan.

Biasanya alasannya adalah :

Membuat Unit Test dan melakukan refactoring itu membuang banyak waktu, dan bisa jadi merusak code yang yang sebelumnya sudah ada. Membuat code sebelumnya yang jalan menjadi tidak bisa dijalankan lagi.


Ok..ok, hal ini sudah kita bahas di :

Mengenai Unit Testing dan Productivitas

atau mau tahu tentang Unit Testing itu sendiri :

Apa itu Test Double

atau tentang Refactoring,

Kenapa enggan melakukan Refactoring

Pelan-pelan kalau artiket diatas dibaca, akhirnya kita akhirnya bisa mengambil kesimpulan kenapa perlu dilakukan 2 hal diatas, yaitu :

  • Membuat Unit Test
  • Melakukan Refactoring

Kedua-duanya merupakan Best Practice yang bagus di dunia Software Engineering.


Lalu masalahnya apa ?


Masalahnya adalah ketika 2 hal diatas dihadapkan pada prioritas.

Dengan waktu yang tersedia sedikit, lebih prioritas mana ?

  • Membuat Unit Test dahulu
  • Melakukan refactoring dahulu

1. Membuat Unit Test dahulu

Biasanya kasus ini tujuannya agar bisa mencapai standar dari coverage test yang organisasi/perusahaan tentukan.

Tujuannya biasanya lebih normatif, atau mengikuti aturan saja.

Misalnya di sebuah perusahaan ditetapkan bahwa minimal Unit Test coverage adalah 80%.

Kalau tidak mencapai angka tersebut, nanti tidak bisa dideploy artifact nya ke server.

Sehingga mau tak mau kita harus membuat unit test dari code kita mencapai standarnya tersebut.

Kecenderungan kita ketika menemui kasus diatas adalah :

  • Mencoba untuk mengakali unit testnya agar bisa mencapai standarnya tersebut.
  • Tujuannya terkadang bukan untuk menguji source code nya kita, akan tetapi lebih agar cuma memenuhi persayaratan minimal coverage saja.
  • Terkadang digunakan Integration Test , dibandingkan memakai Unit Test, dengan tujuan lebih menyingkat waktu.
  • dll.

2. Melakukan refactoring terlebih dahulu.

Biasanya kasus ini tujuannya karena gregetan, gemes, gatel melihat source code yang ada.

Gregetan, gemes, gatel ini terjadi karena source code yang kita lihat bisa saja bertipe spaghetty code, tidak efektif, atau tidak menggunakan prinsip-prinsip Software Engineering yang baik dan benar.

Akibatnya, kita cenderung akan berupaya untuk :

  • Menyederhanakan source code yang ada.
  • Membuatnya sesuai dengan konsep Software Engineering yang baik dan benar.
  • Membuang bagian-bagian yang tidak efektif dan tidak berguna lagi.

Kegiatan refactoring diatas merupakan kegiatan yang membutuhkan waktu yang tidak sedikit.

Banyak dan mungkin saja akan cukup lama.

Refactoring seperti diatas, biasanya membutuhkan waktu untuk :

  • Memahami source code yang lama.
  • Membuat source code baru hasil refactoring.
  • Menguji hasil dari refactoring yang kita buat, apakah tetap berjalan sesuai dengan yang sebelumnya atau tidak.

Kegiatan memahami dan secara bertahap melakukan refactoring merupakan aktifitas otak yang cukup dalam.

Memahami cara orang berlogika dalam menyelesaikan persoalan, kemudian menggantinya dengan logika kita yang kita anggap lebih baik, akan menyita cukup banyak waktu.

Apalagi ditambah dengan aktifitas transformasi dari logika yang lama ke logika yang baru.

Makin meningkat lah kompleksitasnya.


Jadi mana yang lebih baik ?


Coba kita lihat lagi secara baik-baik.

  • Refactoring merupakan aktifitas perbaikan terhadap source code kita.
  • Unit test pada dasarnya bertujuan mencari bug/celah dan memperbaikinya sampai level detail.
  • Secara tidak langsung Unit Test merupakan salah satu alat dalam upaya kita melakukan refactoring juga.

Oleh karena itu sebenarnya Unit Test dengan Refactoring merupakan 2 hal yang saling menunjang.

Saling melengkapi.

Hanya masalah caranya saja yang berbeda.

Apakah langsung semua source code kita refactoring.

Atau sebagian-sebagian saja, memakai perbaikan dan peningkatan unit test yang kita lakukan.

Dan juga mungkin berdasarkan kenyamanan/preferensi dari Software Engineer yang melakukan 2 hal diatas.

Ada yang hobby dalam melakukan refactoring secara terus-menerus, dan percaya diri kalau dilakukan refactoring secara menyeluruh.

Ada juga yang lebih suka bertahap dan progressif, dan dimulai dari Unit test terlebih dahulu.


Jadi ?

Jadi kesimpulannya, tidak perlu dipertentangkan untuk kedua hal diatas.

Semuanya kembali kepada tujuan untuk memperbaiki source code yang kita punyai agar lebih baik, bagus, dan efisien.

Dan preferensi serta tingkat percaya diri dari Software Engineer yang melakukan itu.