go test — Optimization¶

Make the test suite fast without sacrificing signal. Numbers are illustrative.

Exercise 1: Lean on the test cache locally¶

Before — re-running the full suite after a one-line change re-executes everything.

After — let the cache skip unchanged packages:

go test ./...        # changed packages run; the rest print (cached)

Only use -count=1 when you specifically need a forced re-run (e.g., external state).

Exercise 2: Parallelize within and across packages¶

Before — serial tests on a multi-core machine leave cores idle.

After:

func TestX(t *testing.T) { t.Parallel(); /* ... */ }

go test -p 8 -parallel 8 ./...

Ensure parallel tests do not share mutable state, or -race will (correctly) complain.

Exercise 3: Split fast unit from slow integration¶

Before — every PR runs DB/network integration tests, taking minutes.

After — gate them by tag:

go test ./...                    # fast unit gate on every PR
go test -tags=integration ./...  # slow suite on merge/schedule

Exercise 4: Use -short for the inner loop¶

Before — a few long-running tests slow every local run.

After — skip them in quick loops:

if testing.Short() { t.Skip("skipping in -short") }

go test -short ./...     # quick local loop
go test ./...            # full suite in CI

Exercise 5: Cache compilation in CI¶

Before — CI recompiles all test binaries from cold each job.

After:

- uses: actions/cache@v4
  with:
    path: |
      ~/.cache/go-build
      ~/go/pkg/mod
    key: gotest-${{ hashFiles('**/go.sum') }}

The test result cache is usually cold in CI, but the build cache massively speeds compilation.

Exercise 6: Right-size parallelism for the CI quota¶

Before — defaults set -p/-parallel from the host's many cores in a 2-CPU container, oversubscribing and thrashing.

After:

go test -p 2 -parallel 2 ./...   # match the CPU quota

Exercise 7: Reduce per-test setup with TestMain¶

Before — each test spins up an expensive fixture (e.g., a test container) independently.

After — share it once per package:

func TestMain(m *testing.M) {
    startFixture()
    code := m.Run()
    stopFixture()
    os.Exit(code)
}

Measurement checklist¶

• Use the test cache locally; -count=1 only when needed.
• Add t.Parallel() and tune -p/-parallel.
• Tag slow integration tests; keep the PR gate fast.
• Use -short for the inner loop.
• Cache GOCACHE/GOMODCACHE in CI for fast compilation.
• Match parallelism to the CI CPU quota.
• Share expensive fixtures via TestMain.