Skip to main content
Agent skill

Golang Testing

Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices. Use when writing Go tests — table-driven cases, subtests, benchmarks, fuzzing, or coverage.

Get started

Get the complete skill folder, including its scripts and reference files.

·

When to use this skill

Use Golang Testing when an AI agent needs a reusable SKILL.md workflow for this job: Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices. Use when writing Go tests — table-driven cases, subtests, benchmarks, fuzzing, or coverage.

When not to use it

Skip Golang Testing when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/golang-testing
# Save SKILL.md to ~/.claude/skills/golang-testing/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/golang-testing/SKILL.md. For a shared project, commit the folder at .claude/skills/golang-testing/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Golang Testing skill for this task: Use Golang Testing when this documented workflow matches the task. Confirm any required inputs or files before making changes.

What supports this recommendation?

76/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
85/100
Practical detail
76/100
Source evidence
63/100
Source signals
72/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# Go Testing Patterns

Comprehensive Go testing patterns for writing reliable, maintainable tests following TDD methodology.

## When to Activate

- Writing new Go functions or methods - Adding test coverage to existing code - Creating benchmarks for performance-critical code - Implementing fuzz tests for input validation - Following TDD workflow in Go projects

## TDD Workflow for Go

### The RED-GREEN-REFACTOR Cycle

``` RED → Write a failing test first GREEN → Write minimal code to pass the test REFACTOR → Improve code while keeping tests green REPEAT → Continue with next requirement ```

### Step-by-Step TDD in Go

```go // Step 1: Define the interface/signature // calculator.go package calculator

func Add(a, b int) int { panic("not implemented") // Placeholder }

// Step 2: Write failing test (RED) // calculator_test.go package calculator

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) } }

// Step 3: Run test - verify FAIL // $ go test // --- FAIL: TestAdd (0.00s) // panic: not implemented

// Step 4: Implement minimal code (GREEN) func Add(a, b int) int { return a + b }

// Step 5: Run test - verify PASS // $ go test // PASS

// Step 6: Refactor if needed, verify tests still pass ```

## Table-Driven Tests

The standard pattern for Go tests. Enables comprehensive coverage with minimal code.

```go func TestAdd(t *testing.T) { tests := []struct { name string a, b int expected int }{ {"positive numbers", 2, 3, 5}, {"negative numbers", -1, -2, -3}, {"zero values", 0, 0, 0}, {"mixed signs", -1, 1, 0}, {"large numbers", 1000000, 2000000, 3000000}, }

for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got := Add(tt.a, tt.b) if got != tt.expected { t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, got, tt.expected) } }) } } ```

### Table-Driven Tests with Error Cases

```go func TestParseConfig(t *testing.T) { tests := []struct { name string input string want *Config wantErr bool }{ { name: "valid config", input: `{"host": "localhost", "port": 8080}`, want: &Config{Host: "localhost", Port: 8080}, }, { name: "invalid JSON", input: `{invalid}`, wantErr: true, }, { name: "empty input", input: "", wantErr: true, }, { name: "minimal config", input: `{}`, want: &Config{}, // Zero value config }, }

for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got, err := ParseConfig(tt.input)

if tt.wantErr { if err == nil { t.Error("expected error, got nil") } return }

if err != nil { t.Fatalf("unexpected error: %v", err) }

if !reflect.DeepEqual(got, tt.want) { t.Errorf("got %+v; want %+v", got, tt.want) } }) } } ```

## Subtests and Sub-benchmarks

### Organizing Related Tests

```go func TestUser(t *testing.T) { // Setup shared by all subtests db := setupTestDB(t)

t.Run("Create", func(t *testing.T) { user := &User{Name: "Alice"} err := db.CreateUser(user) if err != nil { t.Fatalf("CreateUser failed: %v", err) } if user.ID == "" { t.Error("expected user ID to be set") } })

t.Run("Get", func(t *testing.T) { user, err := db.GetUser("alice-id") if err != nil { t.Fatalf("GetUser failed: %v", err) } if user.Name != "Alice" { t.Errorf("got name %q; want %q", user.Name, "Alice") } })

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

t.Run("Delete", func(t *testing.T) { // ... }) } ```

### Parallel Subtests

```go func TestParallel(t *testing.T) { tests := []struct { name string input string }{ {"case1", "input1"}, {"case2", "input2"}, {"case3", "input3"}, }

for _, tt := range tests { tt := tt // Capture range variable t.Run(tt.name, func(t *testing.T) { t.Parallel() // Run subtests in parallel result := Process(tt.input) // assertions... _ = result }) } } ```

## Test Helpers

### Helper Functions

```go func setupTestDB(t *testing.T) *sql.DB { t.Helper() // Marks this as a helper function

db, err := sql.Open("sqlite3", ":memory:") if err != nil { t.Fatalf("failed to open database: %v", err) }

// Cleanup when test finishes t.Cleanup(func() { db.Close() })

// Run migrations if _, err := db.Exec(schema); err != nil { t.Fatalf("failed to create schema: %v", err) }

return db }

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

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

### Temporary Files and Directories

```go func TestFileProcessing(t *testing.T) { // Create temp directory - automatically cleaned up tmpDir := t.TempDir()

// Create test file testFile := filepath.Join(tmpDir, "test.txt") err := os.WriteFile(testFile, []byte("test content"), 0644) if err != nil { t.Fatalf("failed to create test file: %v", err) }

// Run test result, err := ProcessFile(testFile) if err != nil { t.Fatalf("ProcessFile failed: %v", err) }

// Assert... _ = result } ```

## Golden Files

Testing against expected output files stored in `testdata/`.

```go var update = flag.Bool("update", false, "update golden files")

func TestRender(t *testing.T) { tests := []struct { name string input Template }{ {"simple", Template{Name: "test"}}, {"complex", Template{Name: "test", Items: []string{"a", "b"}}}, }

for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got := Render(tt.input)

golden := filepath.Join("testdata", tt.name+".golden")

if *update { // Update golden file: go test -update err := os.WriteFile(golden, got, 0644) if err != nil { t.Fatalf("failed to update golden file: %v", err) } }

want, err := os.ReadFile(golden) if err != nil { t.Fatalf("failed to read golden file: %v", err) }

if !bytes.Equal(got, want) { t.Errorf("output mismatch:\ngot:\n%s\nwant:\n%s", got, want) } }) } } ```

## Mocking with Interfaces

### Interface-Based Mocking

```go // Define interface for dependencies type UserRepository interface { GetUser(id string) (*User, error) SaveUser(user *User) error }

// Production implementation type PostgresUserRepository struct { db *sql.DB }

func (r *PostgresUserRepository) GetUser(id string) (*User, error) { // Real database query }

// Mock implementation for tests type MockUserRepository struct { GetUserFunc func(id string) (*User, error) SaveUserFunc func(user *User) error }

func (m *MockUserRepository) GetUser(id string) (*User, error) { return m.GetUserFunc(id) }

func (m *MockUserRepository) SaveUser(user *User) error { return m.SaveUserFunc(user) }

// Test using mock func TestUserService(t *testing.T) { mock := &MockUserRepository{ GetUserFunc: func(id string) (*User, error) { if id == "123" { return &User{ID: "123", Name: "Alice"}, nil } return nil, ErrNotFound }, }

service := NewUserService(mock)

user, err := service.GetUserProfile("123") if err != nil { t.Fatalf("unexpected error: %v", err) } if user.Name != "Alice" { t.Errorf("got name %q; want %q", user.Name, "Alice") } } ```

## Benchmarks

### Basic Benchmarks

```go func BenchmarkProcess(b *testing.B) { data := generateTestData(1000) b.ResetTimer() // Don't count setup time

for i := 0; i < b.N; i++ { Process(data) } }

// Run: go test -bench=BenchmarkProcess -benchmem // Output: BenchmarkProcess-8 10000 105234 ns/op 4096 B/op 10 allocs/op ```

### Benchmark with Different Sizes

```go func BenchmarkSort(b *testing.B) { sizes := []int{100, 1000, 10000, 100000}

for _, size := range sizes { b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) { data := generateRandomSlice(size) b.ResetTimer()

for i := 0; i < b.N; i++ { // Make a copy to avoid sorting already sorted data tmp := make([]int, len(data)) copy(tmp, data) sort.Ints(tmp) } }) } } ```

### Memory Allocation Benchmarks

```go func BenchmarkStringConcat(b *testing.B) { parts := []string{"hello", "world", "foo", "bar", "baz"}

b.Run("plus", func(b *testing.B) { for i := 0; i < b.N; i++ { var s string for _, p := range parts { s += p } _ = s } })

b.Run("builder", func(b *testing.B) { for i := 0; i < b.N; i++ { var sb strings.Builder for _, p := range parts { sb.WriteString(p) } _ = sb.String() } })

b.Run("join", func(b *testing.B) { for i := 0; i < b.N; i++ { _ = strings.Join(parts, "") } }) } ```

## Fuzzing (Go 1.18+)

### Basic Fuzz Test

```go func FuzzParseJSON(f *testing.F) { // Add seed corpus f.Add(`{"name": "test"}`) f.Add(`{"count": 123}`) f.Add(`[]`) f.Add(`""`)

f.Fuzz(func(t *testing.T, input string) { var result map[string]interface{} err := json.Unmarshal([]byte(input), &result)

if err != nil { // Invalid JSON is expected for random input return }

// If parsing succeeded, re-encoding should work _, err = json.Marshal(result) if err != nil { t.Errorf("Marshal failed after successful Unmarshal: %v", err) } }) }

// Run: go test -fuzz=FuzzParseJSON -fuzztime=30s ```

### Fuzz Test with Multiple Inputs

```go func FuzzCompare(f *testing.F) { f.Add("hello", "world") f.Add("", "") f.Add("abc", "abc")

f.Fuzz(func(t *testing.T, a, b string) { result := Compare(a, b)

// Property: Compare(a, a) should always equal 0 if a == b && result != 0 { t.Errorf("Compare(%q, %q) = %d; want 0", a, b, result) }

// Property: Compare(a, b) and Compare(b, a) should have opposite signs reverse := Compare(b, a) if (result > 0 && reverse >= 0) || (result < 0 && reverse <= 0) { if result != 0 || reverse != 0 { t.Errorf("Compare(%q, %q) = %d, Compare(%q, %q) = %d; inconsistent", a, b, result, b, a, reverse) } } }) } ```

## Test Coverage

### Running Coverage

```bash # Basic coverage go test -cover ./...

# Generate coverage profile go test -coverprofile=coverage.out ./...

# View coverage in browser go tool cover -html=coverage.out

# View coverage by function go tool cover -func=coverage.out

# Coverage with race detection go test -race -coverprofile=coverage.out ./... ```

### Coverage Targets

| Code Type | Target | |-----------|--------| | Critical business logic | 100% | | Public APIs | 90%+ | | General code | 80%+ | | Generated code | Exclude |

### Excluding Generated Code from Coverage

```go //go:generate mockgen -source=interface.go -destination=mock_interface.go

// In coverage profile, exclude with build tags: // go test -cover -tags=!generate ./... ```

## HTTP Handler Testing

```go func TestHealthHandler(t *testing.T) { // Create request req := httptest.NewRequest(http.MethodGet, "/health", nil) w := httptest.NewRecorder()

// Call handler HealthHandler(w, req)

// Check response resp := w.Result() defer resp.Body.Close()

if resp.StatusCode != http.StatusOK { t.Errorf("got status %d; want %d", resp.StatusCode, http.StatusOK) }

body, _ := io.ReadAll(resp.Body) if string(body) != "OK" { t.Errorf("got body %q; want %q", body, "OK") } }

func TestAPIHandler(t *testing.T) { tests := []struct { name string method string path string body string wantStatus int wantBody string }{ { name: "get user", method: http.MethodGet, path: "/users/123", wantStatus: http.StatusOK, wantBody: `{"id":"123","name":"Alice"}`, }, { name: "not found", method: http.MethodGet, path: "/users/999", wantStatus: http.StatusNotFound, }, { name: "create user", method: http.MethodPost, path: "/users", body: `{"name":"Bob"}`, wantStatus: http.StatusCreated, }, }

handler := NewAPIHandler()

for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var body io.Reader if tt.body != "" { body = strings.NewReader(tt.body) }

req := httptest.NewRequest(tt.method, tt.path, body) req.Header.Set("Content-Type", "application/json") w := httptest.NewRecorder()

handler.ServeHTTP(w, req)

if w.Code != tt.wantStatus { t.Errorf("got status %d; want %d", w.Code, tt.wantStatus) }

if tt.wantBody != "" && w.Body.String() != tt.wantBody { t.Errorf("got body %q; want %q", w.Body.String(), tt.wantBody) } }) } } ```

## Testing Commands

```bash # Run all tests go test ./...

# Run tests with verbose output go test -v ./...

# Run specific test go test -run TestAdd ./...

# Run tests matching pattern go test -run "TestUser/Create" ./...

# Run tests with race detector go test -race ./...

# Run tests with coverage go test -cover -coverprofile=coverage.out ./...

# Run short tests only go test -short ./...

# Run tests with timeout go test -timeout 30s ./...

# Run benchmarks go test -bench=. -benchmem ./...

# Run fuzzing go test -fuzz=FuzzParse -fuzztime=30s ./...

# Count test runs (for flaky test detection) go test -count=10 ./... ```

## Best Practices

**DO:** - Write tests FIRST (TDD) - Use table-driven tests for comprehensive coverage - Test behavior, not implementation - Use `t.Helper()` in helper functions - Use `t.Parallel()` for independent tests - Clean up resources with `t.Cleanup()` - Use meaningful test names that describe the scenario

**DON'T:** - Test private functions directly (test through public API) - Use `time.Sleep()` in tests (use channels or conditions) - Ignore flaky tests (fix or remove them) - Mock everything (prefer integration tests when possible) - Skip error path testing

## Integration with CI/CD

```yaml # GitHub Actions example test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-go@v5 with: go-version: '1.22'

- name: Run tests run: go test -race -coverprofile=coverage.out ./...

- name: Check coverage run: | go tool cover -func=coverage.out | grep total | awk '{print $3}' | \ awk -F'%' '{if ($1 < 80) exit 1}' ```

**Remember**: Tests are documentation. They show how your code is meant to be used. Write them clearly and keep them up to date.

Intended uses

  • Use Golang Testing when this documented workflow matches the task.

Implementation notes

  • Write tests FIRST (TDD)
  • Use table-driven tests for comprehensive coverage
  • Test behavior, not implementation
  • Use t.Helper() in helper functions
  • Use t.Parallel() for independent tests
  • Clean up resources with t.Cleanup()
  • Use meaningful test names that describe the scenario
  • Test private functions directly (test through public API)
  • Use time.Sleep() in tests (use channels or conditions)
  • Ignore flaky tests (fix or remove them)
  • Mock everything (prefer integration tests when possible)
  • Skip error path testing

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.