testing/synctest — menguji concurrency

Tes yang memakai time.Sleep untuk menunggu goroutine selalu berakhir sama: lambat, dan flaky di CI. synctest menjalankan tes dengan jam palsu yang melompat sendiri saat semua goroutine tertidur.

Masalah yang diselesaikannya

// ❌ Tes tradisional untuk kode berbasis waktu
func TestCacheKedaluwarsa(t *testing.T) {
	c := NewCache(100 * time.Millisecond)
	c.Simpan("k", "v")

	time.Sleep(150 * time.Millisecond)   // menebak; lambat; flaky

	if _, ok := c.Ambil("k"); ok {
		t.Error("mau kedaluwarsa")
	}
}

Dengan synctest

import "testing/synctest"

func TestCacheKedaluwarsa(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		c := NewCache(time.Hour)
		c.Simpan("k", "v")

		// Jam palsu: ini TIDAK menunggu satu jam sungguhan.
		// Waktu melompat begitu semua goroutine tertidur.
		time.Sleep(2 * time.Hour)

		if _, ok := c.Ambil("k"); ok {
			t.Error("mau kedaluwarsa setelah 2 jam")
		}
	})
}

ok  contoh.com/toko/internal/cache   0.004s

Menunggu goroutine, bukan menunggu waktu

func TestWorkerMemprosesSemua(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		antrean := make(chan Tugas, 10)
		selesai := &atomic.Int64{}

		w := NewWorker(antrean, selesai)
		go w.Jalankan(t.Context())

		for range 10 {
			antrean <- Tugas{}
		}

		// Menunggu SAMPAI semua goroutine di gelembung ini tertidur
		// atau selesai — bukan menunggu durasi tertentu.
		synctest.Wait()

		if n := selesai.Load(); n != 10 {
			t.Errorf("selesai = %d, mau 10", n)
		}
	})
}

Menguji timeout dan retry

func TestRetryDenganBackoff(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		var percobaan int

		srv := httptest.NewServer(http.HandlerFunc(
			func(w http.ResponseWriter, r *http.Request) {
				percobaan++
				if percobaan < 3 {
					w.WriteHeader(http.StatusServiceUnavailable)
					return
				}
				_, _ = w.Write([]byte(`{"ok":true}`))
			}))
		defer srv.Close()

		k := NewKlien(srv.URL, srv.Client())

		// Backoff-nya 1 dtk, 2 dtk, 4 dtk — dan tesnya tetap selesai
		// dalam milidetik.
		if err := k.Panggil(t.Context()); err != nil {
			t.Fatalf("Panggil() error = %v", err)
		}
		if percobaan != 3 {
			t.Errorf("percobaan = %d, mau 3", percobaan)
		}
	})
}

Deteksi kebuntuan

func TestGoroutineBocor(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		ch := make(chan int)

		go func() {
			ch <- 1        // tidak ada yang membaca
		}()

		synctest.Wait()
		// Tes GAGAL dengan pesan bahwa semua goroutine tertidur —
		// bukan menggantung sampai timeout `go test`.
	})
}

Batasan

Kapan memakainya

1. Kedaluwarsa cache dan TTL.
2. Retry dengan backoff.
3. Timeout dan pembatalan context.
4. Rate limiter berbasis waktu.
5. Worker, penjadwal, dan Ticker.
6. Graceful shutdown — memastikan semuanya benar-benar berhenti.