Какие инструменты используешь при интеграционном тестировании?

Мой подход к интеграционному тестированию в Go

При интеграционном тестировании в Go я использую комбинацию инструментов и практик, которые позволяют эффективно проверять взаимодействие между компонентами системы. Вот мой основной стек и методология:

Основные инструменты и библиотеки

1. Стандартная библиотека testing

Основу составляют встроенные возможности Go, которые я расширяю для интеграционного тестирования:

// Пример структуры интеграционного теста
func TestUserRepository_Integration(t *testing.T) {
    if testing.Short() {
        t.Skip("Пропускаем интеграционный тест в режиме --short")
    }
    
    // Настройка тестового окружения
    db, cleanup := setupTestDatabase(t)
    defer cleanup()
    
    repo := NewUserRepository(db)
    
    // Тестовый сценарий
    user := &User{Name: "Test User", Email: "test@example.com"}
    err := repo.Create(user)
    if err != nil {
        t.Fatalf("Ошибка создания пользователя: %v", err)
    }
    
    // Проверка результата
    retrieved, err := repo.GetByID(user.ID)
    if err != nil {
        t.Fatalf("Ошибка получения пользователя: %v", err)
    }
    
    if retrieved.Email != user.Email {
        t.Errorf("Ожидался email %s, получили %s", user.Email, retrieved.Email)
    }
}

2. Testcontainers для изоляции зависимостей

Для работы с реальными базами данных, брокерами сообщений и другими внешними сервисами использую Testcontainers:

// Пример с PostgreSQL
func TestWithPostgreSQL(t *testing.T) {
    ctx := context.Background()
    
    // Запуск контейнера PostgreSQL
    postgresContainer, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: testcontainers.ContainerRequest{
            Image:        "postgres:15-alpine",
            ExposedPorts: []string{"5432/tcp"},
            Env: map[string]string{
                "POSTGRES_PASSWORD": "password",
                "POSTGRES_USER":     "postgres",
                "POSTGRES_DB":       "testdb",
            },
            WaitingFor: wait.ForLog("database system is ready to accept connections"),
        },
        Started: true,
    })
    defer func() {
        if err := postgresContainer.Terminate(ctx); err != nil {
            t.Logf("Не удалось остановить контейнер: %v", err)
        }
    }()
    
    // Получение подключения к БД
    host, _ := postgresContainer.Host(ctx)
    port, _ := postgresContainer.MappedPort(ctx, "5432")
    dsn := fmt.Sprintf("postgres://postgres:password@%s:%s/testdb", host, port)
    
    db, err := sql.Open("postgres", dsn)
    if err != nil {
        t.Fatalf("Ошибка подключения к БД: %v", err)
    }
    defer db.Close()
    
    // Дальнейшие тесты...
}

3. gomock или mockery для мокинга

Для замены сложных или внешних зависимостей использую генераторы моков:

# Генерация моков с помощью mockery
mockery --name=UserService --dir=./internal --output=./mocks

// Использование моков в интеграционных тестах
func TestIntegrationWithMocks(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()
    
    mockService := mocks.NewMockUserService(ctrl)
    mockService.EXPECT().
        GetUser(gomock.Any(), gomock.Any()).
        Return(&User{ID: 1, Name: "Mocked User"}, nil)
    
    // Тестирование компонента, использующего мок
    handler := NewUserHandler(mockService)
    // ... тестовый сценарий
}

Организация тестовой инфраструктуры

4. Кастомные test helpers и утилиты

Создаю набор вспомогательных функций для часто повторяющихся операций:

// testhelpers/database.go
package testhelpers

func SetupTestDatabase(t *testing.T) (*sql.DB, func()) {
    t.Helper()
    
    // Создание временной БД
    dbName := "test_" + strings.ToLower(t.Name())
    
    // Миграции и наполнение тестовыми данными
    runMigrations(t, dbName)
    
    cleanup := func() {
        // Очистка тестовых данных
        cleanupTestData(t, dbName)
    }
    
    return getConnection(dbName), cleanup
}

5. Docker Compose для сложных сценариев

Для многосервисных интеграционных тестов использую Docker Compose:

# docker-compose.test.yml
version: '3.8'
services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: testpass
      POSTGRES_USER: testuser
      POSTGRES_DB: testdb
    
  redis:
    image: redis:7-alpine
    
  rabbitmq:
    image: rabbitmq:3-management

// Запуск тестового окружения
func TestMultiServiceIntegration(t *testing.T) {
    compose := testhelpers.NewDockerCompose("docker-compose.test.yml")
    defer compose.Down()
    
    err := compose.Up()
    if err != nil {
        t.Fatalf("Не удалось запустить тестовое окружение: %v", err)
    }
    
    // Тесты с использованием всех сервисов...
}

Практики и методологии

Разделение тестов по тегам

Использую теги для категоризации тестов:

# Запуск только интеграционных тестов
go test -tags=integration ./...

# Запуск всех тестов кроме интеграционных
go test ./... -short

Параллельное выполнение

Для ускорения интеграционных тестов применяю параллельное выполнение там, где это безопасно:

func TestParallelIntegration(t *testing.T) {
    t.Parallel()
    
    // Каждый тест работает в изолированном окружении
    // с уникальными именами БД или пространствами имен
}

Тестовые фикстуры и данные

Использую структурированный подход к тестовым данным:

// fixtures/users.go
var TestUsers = []User{
    {
        ID:    1,
        Name:  "Test User 1",
        Email: "user1@test.com",
    },
    {
        ID:    2,
        Name:  "Test User 2",
        Email: "user2@test.com",
    },
}

// В тестах
func TestWithFixtures(t *testing.T) {
    db := setupDB(t)
    loadFixtures(t, db, fixtures.TestUsers)
    // ... тесты
}

Мониторинг и анализ

6. Инструменты для профилирования тестов

Для анализа производительности и проблем в интеграционных тестах:

# Профилирование времени выполнения
go test -cpuprofile=cpu.out -memprofile=mem.out ./...

# Сбор покрытия кода
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

7. Кастомные reporters и логгирование

Для улучшения диагностики создаю расширенные системы логгирования:

type TestReporter struct {
    TestName string
    Start    time.Time
}

func (r *TestReporter) LogStep(step string) {
    duration := time.Since(r.Start)
    fmt.Printf("[%s] %s: %v\n", r.TestName, step, duration)
}

Ключевые принципы, которых я придерживаюсь:

1. Изоляция тестов - каждый тест должен работать в чистом окружении
2. Детерминированность - тесты должны давать одинаковый результат при каждом запуске
3. Ресурсоэффективность - минимизация времени выполнения и потребления ресурсов
4. Читаемость - тесты должны быть понятны и служить документацией
5. Поддержка CI/CD - интеграция с pipelines и системами непрерывной поставки

Такой комплексный подход позволяет создавать надежные интеграционные тесты, которые быстро выполняются, легко поддерживаются и точно отражают поведение системы в реальных условиях.