
Apa itu unit testing
Unit testing adalah pengujian otomatis pada bagian terkecil dari kode program, biasanya satu fungsi atau satu method, untuk memastikan bagian tersebut berjalan sesuai yang diharapkan. Pengujian ini dijalankan berulang kali setiap ada perubahan kode, sehingga kesalahan dapat terdeteksi lebih awal sebelum sampai ke pengguna.
Kenapa unit testing penting
- Mendeteksi bug lebih awal, sebelum kode digabung atau dirilis ke produksi.
- Memberi kepercayaan diri saat melakukan refactor, karena ada jaring pengaman otomatis.
- Berfungsi sebagai dokumentasi hidup tentang bagaimana suatu fungsi seharusnya berperilaku.
- Mempercepat proses code review karena reviewer bisa melihat skenario yang sudah diuji.
Unit test bukan jaminan: apa yang tidak tertangkap
Pendukung unit test kadang menulis seolah test yang lengkap berarti aplikasi bebas bug. Itu berlebihan. Unit test sangat baik menjaga logika yang sudah dipahami dengan benar, tetapi buta terhadap hal yang tidak pernah dibayangkan penulisnya.

Contoh paling mahal dari kolom kanan adalah kebutuhan yang dipahami keliru. Bila developer mengira diskon dihitung sebelum pajak padahal keuangan menghitungnya setelah pajak, developer akan menulis kode dan test yang sama-sama salah, dan keduanya lulus. Test hanya mengonfirmasi pemahaman penulisnya. Karena itu skenario uji untuk perhitungan uang sebaiknya diambil dari contoh nyata yang dihitung oleh orang keuangan, bukan dikarang oleh developer.
Contoh sederhana di Python (pytest)
Berikut contoh fungsi sederhana untuk menghitung diskon, beserta unit test-nya menggunakan pytest:
def hitung_harga_setelah_diskon(harga, persen_diskon):
if persen_diskon < 0 or persen_diskon > 100:
raise ValueError("Persen diskon tidak valid")
return harga - (harga * persen_diskon / 100)
def test_diskon_normal():
assert hitung_harga_setelah_diskon(100000, 10) == 90000
def test_diskon_nol():
assert hitung_harga_setelah_diskon(50000, 0) == 50000
def test_diskon_tidak_valid():
with pytest.raises(ValueError):
hitung_harga_setelah_diskon(100000, 150)
Contoh sederhana di JavaScript (Jest)
function hitungTotal(items) {
return items.reduce((total, item) => total + item.harga * item.qty, 0);
}
test('menghitung total belanja dengan benar', () => {
const items = [{ harga: 10000, qty: 2 }, { harga: 5000, qty: 3 }];
expect(hitungTotal(items)).toBe(35000);
});
test('mengembalikan 0 untuk keranjang kosong', () => {
expect(hitungTotal([])).toBe(0);
});
Prinsip menulis unit test yang baik
- Satu test, satu skenario: hindari menggabungkan banyak pengecekan berbeda dalam satu fungsi test.
- Independen: urutan menjalankan test tidak boleh mempengaruhi hasil test lainnya.
- Cepat dijalankan: hindari memanggil database atau API eksternal asli di dalam unit test, gunakan mock atau stub.
- Uji juga kasus gagal: jangan hanya menguji jalur sukses, tapi juga input tidak valid dan kondisi batas (edge case).
Contoh nyata: bug pembulatan pajak yang lolos ke faktur
Kasus seperti ini sering terjadi di aplikasi penjualan buatan sendiri. Fungsi menghitung pajak memakai angka desimal biasa (float), lalu dibulatkan dengan round(). Di layar semuanya tampak benar, sampai akuntan menemukan selisih satu rupiah antara total faktur dan laporan pajak, dan selisih itu berulang di ratusan faktur.
Penyebabnya, float tidak bisa menyimpan semua pecahan desimal dengan tepat, dan round() di Python memakai pembulatan ke angka genap terdekat untuk nilai tepat di tengah (2,5 menjadi 2, bukan 3). Unit test yang sengaja menguji nilai tengah akan menangkap masalah ini sebelum faktur pertama terbit:
from decimal import Decimal, ROUND_HALF_UP
def hitung_pajak(dpp: Decimal, tarif: Decimal) -> Decimal:
return (dpp * tarif / 100).quantize(Decimal("1"), rounding=ROUND_HALF_UP)
def test_pembulatan_setengah_ke_atas():
# 11% dari 150 = 16,5 dan harus dibulatkan menjadi 17; round(16.5) memberi 16
assert hitung_pajak(Decimal("150"), Decimal("11")) == Decimal("17")
def test_nilai_besar_tetap_tepat():
assert hitung_pajak(Decimal("123456789"), Decimal("11")) == Decimal("13580247")
Dua test kecil ini berjalan dalam hitungan milidetik dan akan terus menjaga fungsi tersebut setiap kali ada developer yang mengubahnya.
Unit test di modul Odoo
Odoo punya kerangka test bawaan. Setiap test berjalan di dalam transaksi database yang dibatalkan setelah selesai, sehingga data uji tidak mengotori database. Contoh untuk modul kustom perhitungan komisi sales:
# komisi_sales/tests/test_komisi.py
from odoo.tests.common import TransactionCase, tagged
@tagged("post_install", "-at_install")
class TestKomisi(TransactionCase):
def test_komisi_lima_persen(self):
sales = self.env["res.users"].create({"name": "Sales Uji", "login": "sales_uji"})
komisi = self.env["komisi.sales"].create({"user_id": sales.id, "omzet": 20_000_000})
self.assertEqual(komisi.nilai_komisi, 1_000_000)
Jalankan dengan perintah berikut di database khusus pengujian, jangan di database produksi:
./odoo-bin -c odoo.conf -d db_uji -i komisi_sales --test-enable --test-tags /komisi_sales --stop-after-init
Unit test, integration test, dan end-to-end test
- Unit test: menguji satu fungsi secara terisolasi. Jumlahnya paling banyak karena murah dan cepat.
- Integration test: menguji beberapa bagian bekerja bersama, misalnya API yang benar-benar menyimpan ke database.
- End-to-end test: meniru pengguna sungguhan di browser, misalnya login, membuat pesanan, lalu mencetak faktur. Paling mendekati kenyataan, tetapi paling lambat, jadi cukup untuk alur yang paling penting.
Tiga jenis test, tiga trade-off
Penjelasan di atas sering diringkas sebagai "piramida pengujian": banyak unit test di dasar, lebih sedikit integration test di tengah, dan sedikit end-to-end test di puncak. Bentuk piramida itu bukan aturan estetika, melainkan hasil dari trade-off yang nyata.

Tim yang hanya menulis end-to-end test biasanya menyerah dalam beberapa bulan: test lambat, sering gagal karena perubahan tampilan kecil, dan sulit diketahui bagian mana yang rusak. Tim yang hanya menulis unit test bisa merilis aplikasi yang setiap fungsinya benar tetapi gagal saat disambungkan ke database atau API. Kombinasi yang sehat untuk aplikasi bisnis: unit test untuk semua perhitungan uang dan aturan, integration test untuk setiap integrasi, dan satu sampai lima end-to-end test untuk alur yang paling mahal bila rusak, misalnya dari pesanan sampai faktur.
Menjalankan test otomatis setiap kode diunggah
Test yang hanya dijalankan saat ingat akan cepat ditinggalkan. Pasang CI agar test berjalan otomatis setiap ada push atau pull request. Contoh minimal dengan GitHub Actions:
# .github/workflows/test.yml
name: test
on: [push, pull_request]
jobs:
pytest:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install -r requirements.txt pytest
- run: pytest -q
Kami menerapkan pengujian seperti ini di proyek Odoo, aplikasi, dan website yang kami bangun. Bila tim Anda butuh bantuan menyusun test atau menguji aplikasi yang sudah berjalan, lihat tahapan layanan QA testing dan kisaran biayanya di halaman harga.

Gambar dalam artikel ini adalah mockup dengan data contoh, bukan tangkapan layar sistem milik klien.
Apa yang diuji lebih dulu di aplikasi bisnis
Waktu tim terbatas, jadi prioritaskan bagian yang kesalahannya paling mahal. Untuk aplikasi ERP, HRIS, atau sistem penjualan, urutan yang masuk akal:
| Area | Contoh skenario uji | Akibat bila lolos ke produksi |
|---|---|---|
| Perhitungan uang | Pajak per baris dan total faktur selalu sama; diskon bertingkat tidak melebihi 100% | Faktur ditolak pelanggan, selisih saat rekonsiliasi |
| Stok | Penerimaan sebagian membuat backorder; stok tidak boleh minus saat validasi | Oversell, selisih stok opname |
| Penggajian | Lembur jam pertama 1,5x dan berikutnya 2x; saldo cuti tidak boleh minus | Kurang atau lebih bayar gaji |
| Hak akses dan persetujuan | PO di atas batas wajib disetujui; staf tidak bisa melihat gaji orang lain | Pembelian tanpa otorisasi, kebocoran data |
| Integrasi | Webhook dengan tanda tangan salah ditolak; pesanan ganda tidak dibuat dua kali | Data palsu masuk, pesanan dobel |
Contoh: menguji aturan cuti di modul Odoo
Misalkan modul HR custom memindahkan persetujuan ke pejabat pengganti saat atasan sedang cuti. Dua test berikut menjaga aturan itu tetap benar setiap kali modul diubah:
from odoo.exceptions import ValidationError
from odoo.tests import TransactionCase, tagged
@tagged('post_install', '-at_install')
class TestDelegasiCuti(TransactionCase):
def test_approver_pindah_saat_atasan_cuti(self):
# atasan cuti 21-24 Des, pengajuan staf harus ke delegasi
cuti = self.buat_cuti(self.staf, '2026-12-22')
self.assertEqual(cuti.approver_id, self.delegasi)
def test_saldo_tidak_boleh_minus(self):
with self.assertRaises(ValidationError):
self.buat_cuti(self.staf, hari=13)
Jalankan dengan odoo-bin -c odoo.conf -d test_db --test-tags /nama_modul --stop-after-init di database uji. Alur bisnis yang diuji di sini sama dengan yang dijelaskan di cara mengajukan cuti di HRIS.
Kenapa cakupan 100% adalah target yang keliru
Banyak tim menetapkan target code coverage, misalnya "minimal 90%". Angka coverage berguna sebagai petunjuk bagian mana yang belum diuji, tetapi buruk sebagai target. Begitu angka itu dijadikan sasaran, developer cenderung menulis test untuk baris yang mudah, bukan untuk logika yang berisiko.

Sebagai patokan, 60 sampai 80% cakupan yang terkonsentrasi pada perhitungan uang, stok, hak akses, dan integrasi jauh lebih berharga daripada 95% yang merata ke getter, setter, dan tampilan. Ukuran yang lebih jujur adalah pertanyaan sederhana setelah setiap bug di produksi: apakah ada test yang seharusnya menangkap ini? Bila jawabannya ya, tulis test itu sebelum memperbaiki bugnya.
Kapan sebaiknya mulai menulis unit test
Idealnya sejak awal pengembangan fitur, bukan setelah aplikasi selesai dibangun. Namun untuk proyek yang sudah berjalan tanpa test sama sekali, mulai dari fungsi-fungsi kritikal yang paling sering menyebabkan bug tetap lebih baik daripada menunggu kondisi ideal.
Pertanyaan yang sering diajukan
Berapa persen kode yang harus tercakup unit test?
Tidak ada angka ajaib. Target 70 sampai 80 persen untuk logika bisnis sudah sehat. Yang lebih penting adalah bagian yang menyangkut uang, stok, dan hak akses benar-benar teruji, bukan mengejar angka cakupan.
Apakah unit test memperlambat pengembangan?
Di minggu pertama sedikit, karena ada kode tambahan yang ditulis. Setelah itu justru mempercepat, karena bug tertangkap di laptop developer, bukan dilaporkan pengguna setelah rilis.
Apa bedanya unit test dengan QA testing manual?
Unit test ditulis developer untuk memeriksa fungsi kecil secara otomatis. QA testing manual dilakukan penguji yang memakai aplikasi seperti pengguna sungguhan untuk menemukan masalah alur, tampilan, dan kebutuhan yang terlewat. Keduanya saling melengkapi.
Bagaimana memulai test di aplikasi lama yang belum punya test sama sekali?
Mulai dari bug berikutnya yang dilaporkan: tulis test yang mereproduksi bug itu, lalu perbaiki kodenya sampai test lolos. Dalam beberapa bulan, bagian yang paling rawan akan terlindungi dengan sendirinya.
Apakah perlu tester khusus bila sudah ada unit test?
Tetap perlu. Unit test memastikan logika kode benar, sedangkan pengujian oleh QA dan pengguna kunci memastikan alur sesuai kebutuhan bisnis dan nyaman dipakai. Keduanya saling melengkapi.
Berapa persen code coverage yang ideal?
Tidak ada angka tunggal. Sebagai patokan, 60 sampai 80% yang terkonsentrasi pada perhitungan uang, stok, hak akses, dan integrasi lebih berharga daripada angka tinggi yang merata. Gunakan coverage untuk menemukan bagian yang belum diuji, bukan sebagai target yang dikejar.