Tes tabel & test double

Menambah kasus uji seharusnya berarti menambah satu baris, bukan menyalin satu fungsi. Tes tabel memberi itu, dan interface implisit Go membuat test double jadi struct kecil belasan baris.

Bentuk tes tabel

func TestHitungOngkir(t *testing.T) {
	t.Parallel()

	kasus := []struct {
		nama    string
		berat   int
		zona    string
		mau     int64
		mauErr  error
	}{
		{"dalam kota ringan", 500, "kota", 9000, nil},
		{"dalam kota berat", 5000, "kota", 25000, nil},
		{"luar pulau", 1000, "luar-pulau", 45000, nil},
		{"berat nol", 0, "kota", 0, ErrBeratTidakValid},
		{"zona tak dikenal", 1000, "bulan", 0, ErrZonaTidakDikenal},
	}

	for _, k := range kasus {
		t.Run(k.nama, func(t *testing.T) {
			t.Parallel()

			got, err := HitungOngkir(k.berat, k.zona)

			if !errors.Is(err, k.mauErr) {
				t.Fatalf("HitungOngkir(%d, %q) err = %v, mau %v",
					k.berat, k.zona, err, k.mauErr)
			}
			if got != k.mau {
				t.Errorf("HitungOngkir(%d, %q) = %d, mau %d",
					k.berat, k.zona, got, k.mau)
			}
		})
	}
}

--- FAIL: TestHitungOngkir/luar_pulau (0.00s)
    ongkir_test.go:31: HitungOngkir(1000, "luar-pulau") = 40000, mau 45000

Kapan tes tabel bukan pilihan

// ❌ Kalau setiap kasus butuh persiapan berbeda, tabelnya penuh
//    field kondisional dan lebih sulit dibaca daripada tes terpisah.
kasus := []struct {
	nama          string
	siapkanDB     func(*testing.T, *sql.DB)
	tiruanGagal   bool
	lewatiJika    string
	...
}

Kalau tabelmu punya lebih dari sekitar enam kolom, atau berisi banyak func, tulis beberapa tes terpisah dengan nama yang jelas. Tes tabel untuk kasus yang seragam.

Test double tanpa pustaka

// Interface yang dideklarasikan domain (Fase 1)
type Penyimpan interface {
	Ambil(ctx context.Context, id int64) (Produk, error)
	Simpan(ctx context.Context, p Produk) error
}

// FAKE: implementasi sederhana yang benar-benar bekerja.
type penyimpanMemori struct {
	mu   sync.Mutex
	data map[int64]Produk
	errAmbil error         // untuk menguji jalur kegagalan
}

func penyimpanBaru(isi ...Produk) *penyimpanMemori {
	m := &penyimpanMemori{data: map[int64]Produk{}}
	for _, p := range isi {
		m.data[p.ID] = p
	}
	return m
}

func (m *penyimpanMemori) Ambil(_ context.Context, id int64) (Produk, error) {
	if m.errAmbil != nil {
		return Produk{}, m.errAmbil
	}
	m.mu.Lock()
	defer m.mu.Unlock()

	p, ok := m.data[id]
	if !ok {
		return Produk{}, ErrTidakDitemukan
	}
	return p, nil
}

func (m *penyimpanMemori) Simpan(_ context.Context, p Produk) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.data[p.ID] = p
	return nil
}

func TestBeli(t *testing.T) {
	simpan := penyimpanBaru(Produk{ID: 1, Stok: 10})
	svc := NewLayanan(simpan, cacheKosong{}, slog.Default())

	if err := svc.Beli(t.Context(), 1, 3); err != nil {
		t.Fatalf("Beli() error = %v", err)
	}

	p, _ := simpan.Ambil(t.Context(), 1)
	if p.Stok != 7 {
		t.Errorf("stok setelah beli = %d, mau 7", p.Stok)
	}
}

func TestBeliSaatDBGagal(t *testing.T) {
	simpan := penyimpanBaru()
	simpan.errAmbil = errors.New("koneksi putus")
	svc := NewLayanan(simpan, cacheKosong{}, slog.Default())

	if err := svc.Beli(t.Context(), 1, 3); err == nil {
		t.Fatal("mau error, dapat nil")
	}
}

Fake versus mock

// Kalau yang PENTING memang interaksinya, catat saja — tetap tanpa pustaka.
type pengirimPalsu struct {
	terkirim []Email
}

func (p *pengirimPalsu) Kirim(_ context.Context, e Email) error {
	p.terkirim = append(p.terkirim, e)
	return nil
}

// lalu di tes:
if len(pengirim.terkirim) != 1 {
	t.Fatalf("email terkirim = %d, mau 1", len(pengirim.terkirim))
}
if pengirim.terkirim[0].Ke != "[email protected]" {
	t.Errorf("penerima = %q", pengirim.terkirim[0].Ke)
}

Menguji waktu

// Waktu disuntikkan sebagai dependensi (Fase 5)
svc := NewLayanan(simpan, katalog,
	DenganJam(func() time.Time {
		return time.Date(2026, 3, 1, 10, 0, 0, 0, time.UTC)
	}))

// Sekarang "kupon kedaluwarsa setelah 30 hari" bisa diuji
// tanpa satu pun time.Sleep.