Go Testing & Quality

Повысьте надежность кода Go с помощью навыка golang-testing для Claude Code. Освойте табличные тесты, обнаружение гонок, бенчмарки и моки для Go-приложений.

Безопасность и тестирование ★ 172,651 GitHub (172,651 ★)

Навык golang-testing предоставляет Claude специализированные знания для написания надежных, production-grade тестов на Go с использованием стандартной библиотеки и лучших отраслевых практик. Он упрощает создание table-driven тестов, бенчмарков и интеграционных тестов, обеспечивая безопасность конкурентного доступа через выявление гонок данных. Используя идиомы Go, такие как t.Helper(), t.Cleanup() и build-теги, этот навык помогает разработчикам поддерживать высокое качество кода, оптимизировать производительность и устранять flaky-тесты в сложных Go-приложениях.

Ключевые особенности

01Автоматическая генерация идиоматических table-driven тестов на Go

02172 651 звезда на GitHub

03Настройка интеграционного тестирования с использованием build-тегов и test-контейнеров

04Безопасность конкурентности с выявлением гонок данных и паттернами параллельного выполнения

05Моки на основе интерфейсов и внедрение зависимостей на уровне сервисов

06Бенчмаркинг производительности и профилирование выделения памяти

Варианты использования

01Рефакторинг существующих тестовых наборов для использования идиоматических Go-паттернов с целью повышения поддерживаемости

02Написание всеобъемлющих модульных тестов для новых Go-пакетов или микросервисов

03Отладка гонок данных и узких мест производительности в конкурентном Go-коде

name

golang-testing

description

Go testing best practices including table-driven tests, test helpers, benchmarking, race detection, coverage analysis, and integration testing patterns. Use when writing or improving Go tests.

metadata

origin

globs

ECC

**/*.go

**/go.mod

**/go.sum

Go Testing

This skill provides comprehensive Go testing patterns extending common testing principles with Go-specific idioms.

Testing Framework

Use the standard go test with table-driven tests as the primary pattern.

Table-Driven Tests

The idiomatic Go testing pattern:

func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name    string
        email   string
        wantErr bool
    }{
        {
            name:    "valid email",
            email:   "user@example.com",
            wantErr: false,
        },
        {
            name:    "missing @",
            email:   "userexample.com",
            wantErr: true,
        },
        {
            name:    "empty string",
            email:   "",
            wantErr: true,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            err := ValidateEmail(tt.email)
            if (err != nil) != tt.wantErr {
                t.Errorf("ValidateEmail(%q) error = %v, wantErr %v",
                    tt.email, err, tt.wantErr)
            }
        })
    }
}

Benefits:

Easy to add new test cases
Clear test case documentation
Parallel test execution with t.Parallel()
Isolated subtests with t.Run()

Test Helpers

Use t.Helper() to mark helper functions:

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

func assertEqual(t *testing.T, got, want interface{}) {
    t.Helper()
    if !reflect.DeepEqual(got, want) {
        t.Errorf("got %v, want %v", got, want)
    }
}

Benefits:

Correct line numbers in test failures
Reusable test utilities
Cleaner test code

Test Fixtures

Use t.Cleanup() for resource cleanup:

func testDB(t *testing.T) *sql.DB {
    t.Helper()

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

    // Cleanup runs after test completes
    t.Cleanup(func() {
        if err := db.Close(); err != nil {
            t.Errorf("failed to close db: %v", err)
        }
    })

    return db
}

func TestUserRepository(t *testing.T) {
    db := testDB(t)
    repo := NewUserRepository(db)
    // ... test logic
}

Race Detection

Always run tests with the -race flag to detect data races:

go test -race ./...

In CI/CD:

- name: Test with race detector
  run: go test -race -timeout 5m ./...

Why:

Detects concurrent access bugs
Prevents production race conditions
Minimal performance overhead in tests

Coverage Analysis

Basic Coverage

go test -cover ./...

Detailed Coverage Report

go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

Coverage Thresholds

# Fail if coverage below 80%
go test -cover ./... | grep -E 'coverage: [0-7][0-9]\.[0-9]%' && exit 1

Benchmarking

func BenchmarkValidateEmail(b *testing.B) {
    email := "user@example.com"

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        ValidateEmail(email)
    }
}

Run benchmarks:

go test -bench=. -benchmem

Compare benchmarks:

go test -bench=. -benchmem > old.txt
# make changes
go test -bench=. -benchmem > new.txt
benchstat old.txt new.txt

Mocking

Interface-Based Mocking

type UserRepository interface {
    GetUser(id string) (*User, error)
}

type mockUserRepository struct {
    users map[string]*User
    err   error
}

func (m *mockUserRepository) GetUser(id string) (*User, error) {
    if m.err != nil {
        return nil, m.err
    }
    return m.users[id], nil
}

func TestUserService(t *testing.T) {
    mock := &mockUserRepository{
        users: map[string]*User{
            "1": {ID: "1", Name: "Alice"},
        },
    }

    service := NewUserService(mock)
    // ... test logic
}

Integration Tests

Build Tags

//go:build integration
// +build integration

package user_test

func TestUserRepository_Integration(t *testing.T) {
    // ... integration test
}

Run integration tests:

go test -tags=integration ./...

Test Containers

func TestWithPostgres(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping integration test")
    }

    // Setup test container
    ctx := context.Background()
    container, err := testcontainers.GenericContainer(ctx, ...)
    assertNoError(t, err)

    t.Cleanup(func() {
        container.Terminate(ctx)
    })

    // ... test logic
}

Test Organization

File Structure

package/
├── user.go
├── user_test.go          # Unit tests
├── user_integration_test.go  # Integration tests
└── testdata/             # Test fixtures
    └── users.json

Package Naming

// Black-box testing (external perspective)
package user_test

// White-box testing (internal access)
package user

Common Patterns

Testing HTTP Handlers

func TestUserHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/users/1", nil)
    rec := httptest.NewRecorder()

    handler := NewUserHandler(mockRepo)
    handler.ServeHTTP(rec, req)

    assertEqual(t, rec.Code, http.StatusOK)
}

Testing with Context

func TestWithTimeout(t *testing.T) {
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()

    err := SlowOperation(ctx)
    if !errors.Is(err, context.DeadlineExceeded) {
        t.Errorf("expected timeout error, got %v", err)
    }
}

Best Practices

Use t.Parallel() for independent tests
Use testing.Short() to skip slow tests
Use t.TempDir() for temporary directories
Use t.Setenv() for environment variables
Avoid init() in test files
Keep tests focused - one behavior per test
Use meaningful test names - describe what's being tested

When to Use This Skill

Writing new Go tests
Improving test coverage
Setting up test infrastructure
Debugging flaky tests
Optimizing test performance
Implementing integration tests

🧪 Что это

Этот навык (skill) предоставляет набор лучших практик и шаблонов для тестирования кода на Go. Он охватывает все основные аспекты: от модульных тестов (unit tests) до интеграционных тестов (integration tests), включая измерение производительности, поиск гонок данных и анализ покрытия. Навык пригодится как новичкам, которые хотят писать качественные тесты с нуля, так и опытным разработчикам, стремящимся улучшить существующую тестовую базу.

⚙️ Как работает

1. Табличные тесты (table-driven tests)

Основной идиоматичный шаблон в Go. Тестовые случаи описываются в виде среза структур, каждая из которых содержит имя, входные данные и ожидаемый результат. Это позволяет легко добавлять новые кейсы, а вложенные вызовы t.Run() обеспечивают изоляцию и читаемые отчёты.

tests := []struct {
    name    string
    email   string
    wantErr bool
}{
    {"valid", "user@example.com", false},
    {"missing @", "userexample.com", true},
}
for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        err := ValidateEmail(tt.email)
        if (err != nil) != tt.wantErr {
            t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", tt.email, err, tt.wantErr)
        }
    })
}

2. Тестовые помощники (test helpers)

Функции-помощники с вызовом t.Helper() упрощают проверки, не загрязняя код повторяющимися условиями. При этом в случае ошибки в логах отображается корректная строка вызова, а не сам helper.

3. Фикстуры и очистка

Для ресурсов (БД, HTTP-серверы) используйте t.Cleanup(): он запускает функцию-очиститель после завершения теста (даже при панике). Это удобнее, чем defer, и не требует явного вызова.

4. 🐞 Детектор гонок (race detector)

Запуск с флагом -race (go test -race ./...) выявляет одновременный доступ к данным без синхронизации. В CI его стоит включать обязательно, так как он отлавливает реальные проблемы, которые проявляются только в production.

5. 📊 Покрытие кода (coverage)

Команды go test -cover и go tool cover -html=coverage.out показывают, какие строки кода выполняются тестами. Можно задать порог (например, 80%) и сделать его обязательным для прохождения CI.

6. ⏱ Бенчмарки (benchmarking)

Функции вида BenchmarkXxx(b *testing.B) измеряют производительность. Используйте b.ResetTimer() для исключения накладных расходов, а benchstat — для сравнения двух замеров (например, до и после оптимизации).

7. Моки (mocking) на основе интерфейсов

Go поощряет использование интерфейсов: для тестирования создаётся структура-мок, реализующая интерфейс, и возвращает заранее заданные значения. Это изолирует тестируемый код от внешних зависимостей.

8. Интеграционные тесты

Помечайте интеграционные тесты build-тегом //go:build integration и запускайте только при необходимости (go test -tags=integration). Для внешних сервисов (например, PostgreSQL) используйте testcontainers-go, чтобы поднимать и удалять контейнеры динамически, с автоматической очисткой через t.Cleanup().

9. Организация файлов и пакетов

Файлы тестов (например, user_test.go) располагаются рядом с тестируемым кодом.
Для black-box тестов используйте отдельный пакет с суффиксом _test (например, package user_test).
White-box тесты размещаются в том же пакете, чтобы иметь доступ к внутренним деталям.
Тестовые данные — в папке testdata/.

10. Частые сценарии

HTTP-обработчики: используйте httptest.NewRequest() и httptest.NewRecorder().
Контекст с таймаутом: тестируйте логику отмены через context.WithTimeout.
Переменные окружения: t.Setenv() гарантирует восстановление исходного значения.
Временные файлы: t.TempDir() создаёт и удаляет директорию автоматически.

🔧 Когда использовать

При написании нового кода на Go — сразу закладывайте качественные тесты.
Когда нужно повысить покрытие существующего проекта.
Для налаживания CI/CD: включите детектор гонок, измерение покрытия и, возможно, интеграционные тесты.
Если тесты флакают (нестабильны) — табличные тесты и helpers помогают структурировать проверки и быстрее находить причину.
Для оптимизации производительности — бенчмарки с benchstat.

⚠️ Важно знать

Детектор гонок (race detector) не ловит все виды гонок, но покрывает большинство реальных случаев.
t.Parallel() ускоряет выполнение, но убедитесь, что тесты действительно независимы (нет общего состояния).
Не злоупотребляйте флагом -short для пропуска интеграционных тестов: он должен быть осмысленно встроен в логику (например, if testing.Short() { t.Skip(...) }).
Избегайте init() в тестовых файлах — он выполняется для всего пакета и может влиять на другие тесты.
При использовании t.Helper() не забывайте вызывать его первой строкой в функции-помощнике.
Для бенчмарков: не делайте лишних операций внутри цикла for i := 0; i < b.N; i++, иначе измерение будет некорректным.

Этот навык даёт проверенную базу для создания надёжных и поддерживаемых тестов на Go. Следуя этим практикам, вы уменьшите количество багов в production и упростите рефакторинг.

Установка одной командой.

npx skillfish add affaan-m/everything-claude-code golang-testing

Источник: https://mcpmarket.com/tools/skills/go-testing-quality-2