Go 1.27 Testing Changes: New Features & Upgrade Pitfalls

httptest.NewTestServer: In-Memory Test Server

Go 1.27 adds

httptest.NewTestServer(t testing.TB, handler http.Handler) *Server

. Unlike NewServer, it:

Accepts testing.TB and registers cleanup via t.Cleanup, eliminating manual defer server.Close().

Uses an in-memory network ( server.Listener == nil), so no real TCP port is consumed.

Reports handler panics as test failures via t.Errorf instead of silently logging to stderr.

Works with testing/synctest because in-memory I/O counts as durable blocking.

Routing Behavior

The returned *httptest.Server provides Client() *http.Client whose DialContext routes any request address to the in-memory listener. Therefore you must use server.Client(); http.DefaultClient will dial the real network (e.g., example.com:80). server.URL is empty until Client(), Start(), or StartTLS() is called, after which it becomes http://example.com.

ts := httptest.NewTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "served by test server, host=%s path=%s", r.Host, r.URL.Path)
}))
// server.Client() ignores the request address
resp, _ := ts.Client().Get("http://totally.other.host/anything")
// plain client dials example.com:80 (real network)
plain := &http.Client{Transport: &http.Transport{
    DialContext: func(_ context.Context, _, addr string) (net.Conn, error) {
        dialed = addr
        return nil, errors.New("blocked by demo")
    },
}}
plain.Get(ts.URL) // dialed = "example.com:80"

This exposes hidden dependencies on http.Get vs. injected *http.Client.

Start() vs Client() Order

If you need a real port, call Start() or StartTLS() before Client(). Reversing the order panics with "Server already started".

ts.Start()        // url becomes http://127.0.0.1:56966, listener non-nil
client := ts.Client()
// vs
client := ts.Client()
ts.Start()        // panic: Server already started

testing/synctest.Sleep: Virtual Time + Wait

Go 1.27 adds synctest.Sleep(d time.Duration), equivalent to time.Sleep(d); Wait(). The package now exports three functions:

func Test(t *testing.T, f func(*testing.T))   // Go 1.25
func Wait()                                   // Go 1.25
func Sleep(d time.Duration)                   // Go 1.27

Virtual Clock & Durable Blocking

synctest.Test

runs in an isolated "bubble" with a virtual clock starting at UTC 2000-01-01. Time advances only when all goroutines are durably blocked (blocked on nil channel, same-bubble channel, select with all cases durably blocked, time.Sleep, sync.Cond.Wait, sync.WaitGroup.Wait). Non-durable: mutexes, network I/O, file I/O, syscalls.

When the bubble is durably blocked:

If a Wait call is pending, it returns.

Else virtual clock jumps to the next wake-up time.

Else deadlock → panic.

What Wait Actually Waits For

Wait

waits until every other goroutine in the bubble is durably blocked or exited. It does not guarantee logical task completion. Example:

synctest.Test(t, func(t *testing.T) {
    var done atomic.Bool
    go func() {
        time.Sleep(1 * time.Second)
        done.Store(true)
    }()
    time.Sleep(1 * time.Second)
    t.Log(done.Load()) // may be false
    synctest.Wait()
    t.Log(done.Load()) // guaranteed true
})

Both goroutines sleep 1s → virtual clock jumps to 1s. Scheduler non-determinism decides which runs first, but after Wait the child has stored true.

Sleep Example

func TestSleep(t *testing.T) {
    realStart := time.Now()
    synctest.Test(t, func(t *testing.T) {
        start := time.Now() // virtual time
        woke := make(chan time.Duration, 1)
        go func() {
            time.Sleep(time.Second)
            woke <- time.Since(start)
        }()
        synctest.Sleep(2 * time.Second)
        select {
        case d := <-woke:
            if d != time.Second { t.Fatalf("worker virtual sleep = %v, want 1s", d) }
        default:
            t.Fatal("worker goroutine not settled after synctest.Sleep")
        }
    })
    if real := time.Since(realStart); real >= 100*time.Millisecond {
        t.Fatalf("2s virtual time should cost ~no real time, took %v", real)
    }
}

Verifies: virtual time advances, other goroutines settle, real time ~0.

Limitations

No t.Run, t.Parallel, t.Deadline inside bubble.

Network/file I/O blocks clock advancement → motivates NewTestServer in-memory network.

Operating on bubble-created channels from outside panics.

NewTestServer + synctest Integration

In-memory HTTP becomes durable blocking, enabling virtual time with real HTTP handlers.

func TestNewTestServerWithSynctest(t *testing.T) {
    realStart := time.Now()
    synctest.Test(t, func(t *testing.T) {
        start := time.Now()
        ts := httptest.NewTestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            time.Sleep(100 * time.Millisecond)
            fmt.Fprint(w, "ok")
        }))
        client := ts.Client()
        var wg sync.WaitGroup
        for range 10 {
            wg.Add(1)
            go func() {
                defer wg.Done()
                resp, _ := client.Get("http://example.com/")
                resp.Body.Close()
            }()
        }
        wg.Wait()
        if elapsed := time.Since(start); elapsed != 100*time.Millisecond {
            t.Fatalf("virtual elapsed = %v, want 100ms", elapsed)
        }
    })
    if real := time.Since(realStart); real >= 100*time.Millisecond {
        t.Fatalf("10 concurrent 100ms requests should cost ~no real time, took %v", real)
    }
}

10 concurrent 100ms handlers → virtual time 100ms, real time ~0.

Concurrent synctest.Sleep Pitfall

Only one Wait caller allowed at a time. Concurrent synctest.Sleep in handlers panics "wait already in progress", caught by NewTestServer and reported as t.Errorf. Fix: use plain time.Sleep in handlers, keep Sleep / Wait in test main flow.

go test -json OutputType Field

New OutputType field on Action: "output" events distinguishes four sources:

Empty string: regular output ( t.Log, fmt.Println). frame: test framework output ( === RUN, --- FAIL). error: error lines ( t.Error, t.Fatal). error-continue: continuation lines of multi-line errors.

{"Time":"2026-10-11T16:30:47.302846+08:00","Action":"output","Package":"...","Test":"TestOutputTypeDemo/fatal","Output":"    outputtype_test.go:31: fatal error stops the subtest
","OutputType":"error"}

Known Issue: -json -v Loses error Types

go test -json

injects -test.v=test2json. Explicit -v overrides it, causing error and error-continue events to disappear (golang/go#70384). Avoid -json -v together.

stdversion Vet Check Enabled by Default

stdversion

(since Go 1.23) flags standard library API usage newer than the go directive in go.mod. Go 1.27 enables it in default go test vet runs.

Example: go 1.24 module using sync.WaitGroup.Go (added in 1.25) fails:

module github.com/.../stdversion

go 1.24
toolchain go1.27.0

func TestWaitGroupGoTooNew(t *testing.T) {
    var wg sync.WaitGroup
    wg.Go(func() {})
    wg.Wait()
}

$ go test -tags stdversion_demo .
./waitgroupgo_demo_test.go:19:5: sync.(*WaitGroup).Go requires go1.25 or later (module is go1.24)
FAIL

Fixes: raise go directive, or disable via go test -vet=off or -vet=-stdversion.

printf Vet: %w Pointer Wrapping

New printf rule (Go 1.27+) flags fmt.Errorf("%w", &err) where &err is a pointer to an error-implementing type. The wrapped error's dynamic type becomes *MyErr, breaking errors.Is(err, MyErr{...}), errors.As, and type assertions.

type myErr struct{ msg string }
func (e myErr) Error() string { return e.msg } // value receiver → both myErr and *myErr implement error

// Bad: wraps *myErr
err := fmt.Errorf("operation failed: %w", &myErr{msg: "boom"})
// errors.Is(err, myErr{...}) fails

Vet error:

%w wants operand of error type myErr, not pointer type *myErr (defeats errors.Is)

Only active when go directive ≥ 1.27. Correct: wrap the value myErr{msg: "boom"}.

Other Changes

goroutineleak

profile graduated: /debug/pprof/goroutineleak detects permanently blocked goroutines via GC reachability.

Prefer testing/cryptotest.SetGlobalRandom over deprecated crypto/tls.Config.Rand for reproducible crypto tests.

Upgrade Checklist

Run go vet ./... before raising go directive to catch stdversion / printf issues.

Audit fmt.Errorf("%w", ...) for pointer arguments, especially &err.

If stdversion fails, decide whether to raise go directive or adjust vet config.

Update custom test reporters for -json OutputType; avoid -json -v.