Go Testing

// math_test.go
package math_test

import "testing"

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5

    if got != want {
        t.Errorf("Add(2, 3) = %d; want %d", got, want)
    }
}

func TestDivide(t *testing.T) {
    tests := []struct {
        name    string
        a, b    float64
        want    float64
        wantErr bool
    }{
        {"positive",   10, 2,  5,  false},
        {"negative",   -6, 3, -2,  false},
        {"divide by 0", 1,  0,  0,  true},
    }

    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            got, err := Divide(tc.a, tc.b)

            if (err != nil) != tc.wantErr {
                t.Fatalf("wantErr=%v, got err=%v", tc.wantErr, err)
            }
            if !tc.wantErr && got != tc.want {
                t.Errorf("got %v, want %v", got, tc.want)
            }
        })
    }
}

// map[string]struct gives free names, no separate name field needed
func TestTrim(t *testing.T) {
    tests := map[string]struct{
        input, want string
    }{
        "leading spaces":  {"  hello",   "hello"},
        "trailing spaces": {"hello  ",   "hello"},
        "both":            {"  hello  ", "hello"},
        "empty":           {"",           ""},
    }

    for name, tc := range tests {
        t.Run(name, func(t *testing.T) {
            if got := strings.TrimSpace(tc.input); got != tc.want {
                t.Errorf("got %q, want %q", got, tc.want)
            }
        })
    }
}

func TestUser(t *testing.T) {
    t.Run("create", func(t *testing.T) {
        // ...
    })

    t.Run("delete", func(t *testing.T) {
        t.Run("existing", func(t *testing.T) { /* ... */ })
        t.Run("not found", func(t *testing.T) { /* ... */ })
    })
}

// Run only delete subtests:
// go test -run TestUser/delete
// go test -run TestUser/delete/not_found   (spaces become underscores)

func TestProcessItems(t *testing.T) {
    items := []string{"a", "b", "c"}

    for _, item := range items {
        item := item  // capture loop variable (required pre-Go 1.22)
        t.Run(item, func(t *testing.T) {
            t.Parallel()  // call immediately after t.Run body opens
            process(item)
        })
    }
    // Parent waits for all parallel subtests before returning
}

// t.Parallel() signals the test runner to pause this subtest,
// run the rest of the parent, then run all parallel subtests together.

func BenchmarkJoin(b *testing.B) {
    words := []string{"go", "is", "fast"}

    for i := 0; i < b.N; i++ {
        strings.Join(words, " ")
    }
}

// Run benchmarks (not run by default)
// go test -bench=. ./...
// go test -bench=BenchmarkJoin -benchmem ./...

// -benchmem adds: bytes/op and allocs/op columns
// BenchmarkJoin-8   3842106   31.2 ns/op   24 B/op   1 allocs/op

// Without t.Helper(): failure points to line inside assertEqual
// With t.Helper():    failure points to the assertEqual call site

func assertEqual[T comparable](t *testing.T, got, want T) {
    t.Helper()
    if got != want {
        t.Errorf("got %v, want %v", got, want)
    }
}

func assertNoError(t *testing.T, err error) {
    t.Helper()
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
}

func TestSomething(t *testing.T) {
    result, err := doWork()
    assertNoError(t, err)        // failure reported here ✓
    assertEqual(t, result, "ok") // failure reported here ✓
}

// Return the thing under test and a cleanup function
func newTestServer(t *testing.T) *Server {
    t.Helper()
    s, err := NewServer(":0")  // :0 picks a free port
    if err != nil {
        t.Fatalf("newTestServer: %v", err)
    }
    t.Cleanup(func() { s.Close() })
    return s
}

func TestEndpoint(t *testing.T) {
    s := newTestServer(t)       // server closes automatically when test ends
    resp, err := http.Get(s.URL() + "/health")
    assertNoError(t, err)
    assertEqual(t, resp.StatusCode, 200)
}

// Production code depends on an interface, not a concrete type
type Mailer interface {
    Send(to, subject, body string) error
}

type UserService struct{ mailer Mailer }

func (s *UserService) Register(email string) error {
    // ... create user ...
    return s.mailer.Send(email, "Welcome", "...")
}

// Fake for tests — records calls, no real email sent
type fakeMailer struct {
    sent []string
}

func (f *fakeMailer) Send(to, _, _ string) error {
    f.sent = append(f.sent, to)
    return nil
}

func TestRegister(t *testing.T) {
    m := &fakeMailer{}
    svc := &UserService{mailer: m}
    svc.Register("alice@example.com")

    if len(m.sent) != 1 || m.sent[0] != "alice@example.com" {
        t.Errorf("expected welcome email, got: %v", m.sent)
    }
}

import "net/http/httptest"

func TestHealthHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/health", nil)
    w   := httptest.NewRecorder()

    HealthHandler(w, req)

    resp := w.Result()
    if resp.StatusCode != http.StatusOK {
        t.Errorf("got %d, want 200", resp.StatusCode)
    }
}

// httptest.NewServer — spin up a real HTTP server for integration tests
ts := httptest.NewServer(myHandler())
defer ts.Close()
resp, _ := http.Get(ts.URL + "/health")