Go Test Cheat Sheet for Everyday Testing Work in One Place

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"
)

func double(n int) int { return n * 2 }

// 1. table test with named cases
func TestTable(t *testing.T) {
	for _, c := range []struct {
		name     string
		in, want int
	}{{"zero", 0, 0}, {"pos", 2, 4}, {"neg", -3, -6}} {
		t.Run(c.name, func(t *testing.T) {
			if got := double(c.in); got != c.want {
				t.Errorf("double(%d) = %d, want %d", c.in, got, c.want)
			}
		})
	}
}

// 2. helper: failures point at the caller
func mustDouble(t *testing.T, in, want int) {
	t.Helper()
	if got := double(in); got != want {
		t.Fatalf("double(%d) = %d, want %d", in, got, want)
	}
}

func TestHelper(t *testing.T) { mustDouble(t, 4, 8) }

// 3. temp dir, cleanup, env
func TestTempAndEnv(t *testing.T) {
	dir := t.TempDir() // removed automatically
	path := filepath.Join(dir, "note.txt")
	if err := os.WriteFile(path, []byte("hi"), 0o600); err != nil {
		t.Fatal(err)
	}
	t.Setenv("APP_MODE", "test") // restored automatically
	t.Cleanup(func() { t.Logf("cleanup runs last, file existed: %v", fileExists(path)) })
	t.Logf("APP_MODE=%s", os.Getenv("APP_MODE"))
}

func fileExists(p string) bool { _, err := os.Stat(p); return err == nil }

// 4. HTTP handler without a server
func TestHandler(t *testing.T) {
	h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusTeapot) })
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest("GET", "/", nil))
	t.Logf("status=%d", rec.Code)
}

// 5. skip
func TestSkipShort(t *testing.T) {
	if testing.Short() {
		t.Skip("slow")
	}
	t.Log("full mode")
}

// 6. parallel subtests
func TestParallel(t *testing.T) {
	for _, n := range []int{1, 2, 3} {
		t.Run("n", func(t *testing.T) {
			t.Parallel()
			if double(n) != n+n {
				t.Fail()
			}
		})
	}
}

// 7. benchmark and 8. fuzz and 9. example
func BenchmarkDouble(b *testing.B) {
	for b.Loop() {
		double(21)
	}
}

func FuzzDouble(f *testing.F) {
	f.Add(3)
	f.Fuzz(func(t *testing.T, n int) {
		if double(n) != n+n {
			t.Fatal("not additive")
		}
	})
}

func Example_double() {
	fmt.Println(double(4))
	// Output: 8
}

func main() {}

G='s/ \([0-9.]+s\)//; s#^ +[a-z_0-9]+\.go:[0-9]+: #    #; s/\t[0-9.]+s$//'
echo '$ go test -v -short'; go test -count=1 -v -short . 2>&1 | grep -vE '^(=== |PASS)' | sed -E "$G" | head -30
echo; echo '$ go test -run "TestTable/(pos|neg)" -v'; go test -count=1 -run 'TestTable/(pos|neg)' -v . 2>&1 | grep -E '^\s*---' | sed -E "$G"
echo; echo '$ go test -run "^$" -bench Double -benchtime 100x'; go test -count=1 -run '^$' -bench Double -benchtime 100x . 2>&1 | grep -E '^Benchmark' | sed -E 's/[[:space:]]+[0-9.]+ ns\/op.*/ ... ns\/op/'
echo; echo '$ go test -run "^$" -fuzz FuzzDouble -fuzztime 200x'; go test -count=1 -run '^$' -fuzz FuzzDouble -fuzztime 200x . 2>&1 | grep -E 'PASS|ok' | sed -E 's/\t[0-9.]+s//' | head -2

$ go test -v -short
--- PASS: TestTable
    --- PASS: TestTable/zero
    --- PASS: TestTable/pos
    --- PASS: TestTable/neg
--- PASS: TestHelper
    APP_MODE=test
    cleanup runs last, file existed: true
--- PASS: TestTempAndEnv
    status=418
--- PASS: TestHandler
    slow
--- SKIP: TestSkipShort
--- PASS: TestParallel
    --- PASS: TestParallel/n
    --- PASS: TestParallel/n#01
    --- PASS: TestParallel/n#02
--- PASS: FuzzDouble
    --- PASS: FuzzDouble/seed#0
--- PASS: Example_double
ok  	example.test/lab

$ go test -run "TestTable/(pos|neg)" -v
--- PASS: TestTable
    --- PASS: TestTable/pos
    --- PASS: TestTable/neg

$ go test -run "^$" -bench Double -benchtime 100x
BenchmarkDouble-10    	     100 ... ns/op

$ go test -run "^$" -fuzz FuzzDouble -fuzztime 200x
PASS
ok  	example.test/lab