go-testing

Files (1)

• SKILL.md

SKILL.md (first lines)

# Go Testing

Every piece of logic must be tested.

## Test Libraries

| Library | When to use |
|---------|------------|
| `testify/require` | **Default** — fails fast, clear messages |
| `testify/assert` | Only when the test should continue after a failure |
| `google/go-cmp` | Deep comparisons with custom `cmp.Option`s |
| `gock` | Mock HTTP calls — never hit real endpoints in tests |
| `testcontainers` | Integration tests with external services (databases, queues) |

**Favor `require` over `assert`.** It fails immediately and prevents cascading noise.

## Table-Driven Tests

The default pattern. Use for all new tests.

```go
func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name    string
        email   string
        want    bool
        wantErr string // use sentinel errors when possible (see go-style)
    }{
        {"valid email", "user@example.com", true, ""},
        {"empty email", "", false, "email cannot be empty"},
        {"invalid format", "not-an-email", false, "invalid email format"},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := ValidateEmail(tt.email)
            if tt.wantErr != "" {
                require.ErrorContains(t, err, tt.wantErr)
                return
            }
            require.NoError(t, err)
            require.Equal(t, tt.want, got)
        })
    }
}
```

When testing sentinel errors, use `require.ErrorIs(t, err, ErrNotFound)` instead of string matching.

## Test Helpers and Setup

- Mark helpers with `t.Helper()` — no exceptions. Stack traces point to the calling test.
- Use `t.Cleanup(fn)` for teardown instead of `defer` — it runs even if the test calls `t.Fatal`.
- Arrange-act-assert structure. Every time.

```go
func setupTestDB(t *testing.T) *DB {
    t.Helper()
    db, err := NewDB(":memory:")
    require.NoError(t, err)
    t.Cleanup(func() { db.Close() })
    return db
}
```

## Parallel Tests

Use `t.Parallel()` for independent subtests to speed up suites.

```go
for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        t.Parallel()
        // ...
    })
}
```

Go 1.22+: loop variable is per-iteration scoped — `tt := tt` capture is no longer needed.

## Mocking

Mock via interfaces. Define mocks in the test file, not production code. Keep them minimal.

```go
type MockEmailSender struct {
    Sent []Email
    Err  error // set to simulate failure
}

func (m *MockEmailSender) Send(to, subject, body string) error {
    if m.Err != nil {
        return m.Err
    }
    m.Sent = append(m.Sent, Email{to, subject, body})
    return nil
}
```

## Fuzzing

Use `testing.F` for input-discovery testing on parsers, validators, and serialization.

```go
func FuzzParseConfig(f *testing.F) {
    f.Add([]byte(`{"key": "value"}`))
    f.Add([]byte(`{}`))

    f.Fuzz(func(t *testing.T, data []byte) {
        cfg, err := ParseConfig(data)
        if err != nil {
            return // invalid input is expected
        }
        // round-trip: marshal back and re-parse
        out, err := cfg.Marshal()
        require.NoError(t, err)
        require.Equal(t, cfg, mustParse(t, out))
    })
}

From els0r/skills, MIT.

More from els0r/skills