Dasar-dasar testing
Tes adalah program kecil yang memeriksa program lain. Seperti apa unit test yang baik, kasus mana yang dipilih, bagaimana tes yang gagal menunjuk ke bug, regression test, piramida tes, dan gagasan yang sama di pytest, Go, test runner Node, dan PHPUnit.
Setiap programmer melakukan testing. Pertanyaannya, apakah Anda mengetes secara manual, dengan mengklik ke sana kemari dan melihat hasilnya, atau menuliskan pemeriksaannya sebagai kode supaya bisa dijalankan lagi dalam sedetik, setiap kali ada yang berubah. Bagian ini membahas jenis kedua.
Kita sudah dua kali bertemu tes. Bagian 12 memakai characterization test untuk mengunci apa yang dilakukan kode yang sudah ada. Bagian 13 membahas kegagalan yang diduga, yang justru merupakan kasus yang perlu dicakup tes. Sekarang kita bahas testing secara khusus.
Tes adalah program kecil yang memeriksa program lain
Unit testing adalah “a form of software testing by which isolated source code is tested to validate expected behavior”: kode diuji secara terpisah untuk memastikan perilakunya sesuai harapan. Sederhananya: panggil sebuah fungsi dengan input yang diketahui, lalu cek apakah outputnya sesuai.
Ini fungsi harga dari bagian 12, sedikit dirapikan:
def final_price(price, qty):
"""Price for `qty` items: 5% off from 10 items, never below zero."""
total = price * qty
if qty >= 10:
total = total * 95 // 100
return max(total, 0)
Dan tesnya, memakai pytest. pytest “will run all files of the form test_*.py or *_test.py”, menjalankan semua file dengan pola nama itu, dan “You can use the assert statement to verify test expectations”: cukup pakai assert. Tidak perlu class atau method khusus:
from pricing import final_price
def test_single_item_has_no_discount():
# arrange
price, qty = 100, 1
# act
result = final_price(price, qty)
# assert
assert result == 100
Tiga komentar itu menunjukkan bentuk umum sebuah tes, yang sering disebut arrange, act, assert: siapkan input, panggil fungsinya, periksa hasilnya. Kebanyakan tes cukup pendek sehingga komentarnya tidak perlu, tapi bentuknya selalu ada.
Kasus mana yang dites
Anda tidak bisa mengetes semua input. Anda memilih beberapa yang penting. Kebiasaan yang baik adalah berpikir per kelompok:
- Kasus normal. Satu barang, beberapa barang.
- Batas. Tempat perilaku berubah: 9 barang (tanpa diskon) dan 10 barang (dapat diskon). Bug off-by-one bersarang di sini, seperti di loop bagian 6.
- Kosong dan nol. Nol barang, harga nol, list kosong.
- Input tidak valid atau aneh. Baris refund dengan
qty = -1dari bagian 12. - Nilai yang dikenal rawan.
333 × 10dengan diskon 5% adalah 3.163,5, jadi ini menguji pembulatannya.
parametrize di pytest memungkinkan Anda menulis contoh-contoh sebagai tabel, sehingga mudah dibaca dan mudah ditambah:
@pytest.mark.parametrize("price, qty, expected", [
(0, 5, 0),
(100, 0, 0),
(333, 10, 3163), # rounds down
(85000, 12, 969000),
])
def test_final_price_examples(price, qty, expected):
assert final_price(price, qty) == expected
Jalankan seluruh file:
test_pricing.py::test_single_item_has_no_discount PASSED [ 12%]
test_pricing.py::test_ten_items_get_five_percent_off PASSED [ 25%]
test_pricing.py::test_nine_items_get_no_discount PASSED [ 37%]
test_pricing.py::test_refund_rows_never_go_negative PASSED [ 50%]
test_pricing.py::test_final_price_examples[0-5-0] PASSED [ 62%]
test_pricing.py::test_final_price_examples[100-0-0] PASSED [ 75%]
test_pricing.py::test_final_price_examples[333-10-3163] PASSED [ 87%]
test_pricing.py::test_final_price_examples[85000-12-969000] PASSED [100%]
============================== 8 passed in 0.02s ===============================
Delapan pemeriksaan dalam 0,02 detik. Mengklik kasus yang sama secara manual butuh beberapa menit, dan tidak ada yang melakukannya setiap kali ada perubahan.
Tes yang gagal adalah petunjuk, bukan hukuman
Tes baru benar-benar berguna saat ada yang rusak. Misalkan seseorang “menyederhanakan” kondisi dari qty >= 10 menjadi qty > 10. Kelihatannya tidak berbahaya. Tes berkata lain:
> assert final_price(100, 10) == 950
E assert 1000 == 950
E + where 1000 = final_price(100, 10)
test_pricing.py:13: AssertionError
...
FAILED test_pricing.py::test_ten_items_get_five_percent_off - assert 1000 == 950
FAILED test_pricing.py::test_final_price_examples[333-10-3163] - assert 3330 ...
2 failed, 6 passed in 0.01s
Outputnya menyebut tes mana, baris mana, apa yang diharapkan, dan apa yang didapat. Dengan 10 barang, pelanggan tidak lagi mendapat diskon. Ketahuan dalam sedetik, di komputer developer, bukan oleh pelanggan.
Karena itu pula nama tes sebaiknya menggambarkan perilaku. test_ten_items_get_five_percent_off yang gagal sudah memberi tahu masalahnya sebelum Anda membaca apa pun. test_price_2 tidak.
Gagasan yang sama di bahasa lain
Setiap bahasa populer punya cara standar untuk menulis tes. Bentuknya sama; hanya sintaksnya yang berbeda.
Go punya testing bawaan. “Package testing provides support for automated testing of Go packages”, dan tes ditaruh di file yang namanya berakhiran _test.go, dalam fungsi berbentuk func TestXxx(*testing.T). Kode Go sering memakai table-driven test, gagasan yang sama dengan parametrize:
func TestParseQty(t *testing.T) {
tests := []struct {
name string
raw string
want int
wantErr bool
}{
{"plain number", "3", 3, false},
{"spaces around", " 12 ", 12, false},
{"letters", "3x", 0, true},
{"empty", "", 0, true},
{"zero", "0", 0, true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := ParseQty(tt.raw)
if (err != nil) != tt.wantErr {
t.Fatalf("ParseQty(%q) error = %v, wantErr %v", tt.raw, err, tt.wantErr)
}
if got != tt.want {
t.Errorf("ParseQty(%q) = %d, want %d", tt.raw, got, tt.want)
}
})
}
}
--- PASS: TestParseQty (0.00s)
--- PASS: TestParseQty/plain_number (0.00s)
--- PASS: TestParseQty/spaces_around (0.00s)
--- PASS: TestParseQty/letters (0.00s)
--- PASS: TestParseQty/empty (0.00s)
--- PASS: TestParseQty/zero (0.00s)
PASS
Perhatikan bahwa tiga dari lima kasus menguji error. Memastikan input yang buruk ditolak sama pentingnya dengan memastikan input yang baik berjalan.
JavaScript: Node juga punya runner bawaan; “The node:test module facilitates the creation of JavaScript tests.”
import { test } from "node:test";
import assert from "node:assert/strict";
import { formatRupiah } from "./rupiah.js";
test("adds thousands separators", () => {
assert.equal(formatRupiah(1500000), "Rp1.500.000");
});
Kalau seseorang mengganti pemisahnya menjadi koma, node --test menunjukkan persis apa bedanya:
✖ adds thousands separators
AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
+ actual - expected
+ 'Rp1,500,000'
- 'Rp1.500.000'
PHP: alat standarnya PHPUnit. Class tes meng-extend TestCase, dan setiap method publik test... adalah satu tes:
use PHPUnit\Framework\TestCase;
final class PricingTest extends TestCase
{
public function testTenItemsGetFivePercentOff(): void
{
$this->assertSame(950, finalPrice(100, 10));
}
public function testRefundRowsNeverGoNegative(): void
{
$this->assertSame(0, finalPrice(100, -1));
}
}
assertSame memeriksa nilai dan tipe, jadi "950" tidak akan lolos untuk 950. Ini penting di PHP, dengan alasan yang sudah dibahas di bagian 5 dan 13.
Regression test: setiap bug cukup diperbaiki sekali
Regresi adalah bug yang muncul lagi. Regression testing adalah “re-running functional and non-functional tests to ensure that previously developed and tested software still performs as expected after a change”: menjalankan ulang tes untuk memastikan perangkat lunak yang sudah teruji masih bekerja setelah ada perubahan.
Kebiasaan yang membuat ini berhasil sederhana: saat memperbaiki bug, tulis dulu tes yang gagal karena bug itu. Lalu perbaiki kodenya dan lihat tesnya lulus. Bug refund dari bagian 12 akan mendapat:
def test_refund_rows_never_go_negative():
assert final_price(100, -1) == 0
Sekarang bug itu tidak bisa diam-diam kembali. Kalau seseorang menghapus max(total, 0) saat “merapikan”, tesnya akan menangkap, dan pagar Chesterton dari bagian 12 kini punya penjaga.
Menulis tes lebih dulu bisa diterapkan ke semua kode baru. Test-driven development (TDD) adalah “writing an automated unit-level test case that fails, then writing just enough code to make the test pass, then refactoring both the test code and the production code, then repeating with another new test case”: tulis tes yang gagal, tulis kode secukupnya sampai lulus, rapikan, lalu ulangi dengan tes berikutnya. Anda tidak harus selalu bekerja dengan cara itu, tapi mencobanya pada fungsi kecil adalah latihan yang baik: Anda dipaksa memutuskan apa yang harus dilakukan fungsi sebelum memutuskan bagaimana caranya.
Jenis-jenis tes, dan piramidanya
Tidak semua tes adalah unit test:
- Unit test memeriksa satu fungsi atau class secara terpisah. Cepat, tepat, dan jumlahnya banyak.
- Integration test memeriksa apakah bagian-bagian bekerja bersama: kode Anda dengan database sungguhan, dua layanan yang saling bicara.
- End-to-end test menjalankan seluruh aplikasi, sering lewat browser, seperti yang dilakukan pengguna.
Piramida tes dari Martin Fowler merangkum keseimbangannya: “you should have many more low-level UnitTests than high level BroadStackTests running through a GUI”, unit test tingkat rendah harus jauh lebih banyak daripada tes tingkat tinggi lewat antarmuka. Alasannya biaya. Tes yang berjalan end-to-end lewat UI “are: brittle, expensive to write, and time consuming to run”: rapuh, mahal ditulis, dan lama dijalankan. Beberapa tes seperti itu tetap berharga, untuk memastikan semuanya tersambung dengan benar. Tapi kebanyakan pemeriksaan sebaiknya ada di tingkat bawah, tempat tes berjalan cepat dan langsung menunjuk ke masalahnya.
Apa yang membuat kode mudah dites
Anda akan cepat sadar bahwa sebagian kode mudah dites dan sebagian menyiksa. Bedanya kebanyakan sudah dibahas di bagian 7:
- Pure function sangat mudah dites. Input sama, output sama, tidak ada yang perlu disiapkan.
final_pricecukup satu baris per tes. - Side effect membuat tes sulit. Fungsi yang membaca jam, memanggil API, dan menulis ke database butuh semua itu dipalsukan atau disiapkan sebelum bisa dites.
- Jadi pisahkan logika dari I/O. Laporan di bagian 9 punya satu fungsi yang membaca file dan empat fungsi murni yang mengerjakan isinya. Empat dari lima mudah dites.
Saat sesuatu sulit dites, sering kali itu petunjuk soal desain, bukan masalah testing.
Yang tidak bisa dilakukan tes
Tes memeriksa kasus yang Anda pikirkan. Tes tidak bisa membuktikan bahwa tidak ada bug, hanya bahwa pemeriksaan-pemeriksaan ini lulus. Dijkstra sudah menyampaikan ini puluhan tahun lalu: testing bisa menunjukkan bahwa bug ada, tapi tidak pernah bisa menunjukkan bahwa bug tidak ada.
Jadi tes bukan pengganti berpikir. Tes adalah cara menuliskan pemikiran Anda supaya komputer bisa memeriksanya lagi, setiap kali, tanpa lelah.
Kenapa ini penting sehari-hari
- Mengubah kode tanpa takut. Dengan tes, refactoring (bagian 17) dan upgrade jadi pekerjaan rutin, bukan pertaruhan.
- Umpan balik lebih cepat. Tes yang gagal dalam sedetik jauh lebih baik daripada laporan bug seminggu kemudian.
- Dokumentasi yang tidak bisa basi. Nama tes dan contohnya menunjukkan cara kode dimaksudkan untuk dipakai, dan akan gagal kalau sudah tidak benar lagi.
- Memeriksa kode hasil AI. Menulis beberapa tes untuk kode yang bukan Anda tulis (oleh orang lain atau oleh AI) adalah salah satu cara tercepat untuk tahu apakah kode itu benar-benar melakukan yang diklaimnya. Bagian 24 akan kembali ke sini.
Coba sendiri
- Tulis tes untuk
final_priceyang mencakup 9, 10, dan 11 barang. Lalu rusak kondisinya dengan sengaja dan lihat tesnya gagal. - Pilih satu fungsi di kode Anda dan daftar kasus normal, batas, kosong, dan input tidak validnya. Ubah daftar itu jadi tes parametrize atau table-driven.
- Lain kali memperbaiki bug, tulis dulu tes yang gagal.
- Cari fungsi yang sulit dites. Apa yang perlu dipindahkan keluar supaya logika intinya jadi murni?
Ringkasan
- Unit test memanggil kode dengan input yang diketahui dan memeriksa outputnya; bentuknya arrange, act, assert.
- Pilih kasus per kelompok: normal, batas, kosong/nol, tidak valid, nilai rawan.
- Tes yang gagal menunjukkan apa, di mana, yang diharapkan, dan yang didapat; beri nama tes yang menggambarkan perilaku.
- Setiap bahasa punya alat standar: pytest, package testing di Go, node:test, PHPUnit. Tabel contoh bisa dipakai di semuanya.
- Regression test: saat memperbaiki bug, tulis tes yang gagal lebih dulu.
- Ikuti piramida tes: banyak unit test, lebih sedikit integration test, beberapa end-to-end test.
- Pure function mudah dites; pisahkan logika dari I/O.
- Tes menunjukkan bug ada, tidak pernah menunjukkan bug tidak ada.
Referensi
- Get Started, dokumentasi pytest.
- testing package, dokumentasi Go.
- Test runner (node:test), dokumentasi Node.js.
- Dokumentasi PHPUnit.
- Martin Fowler, TestPyramid.
- Unit testing, Regression testing, dan Test-driven development, Wikipedia.