Тестирование в Go: testing + table-driven tests

1// calculator.go
2package main
3
4func Add(a, b int) int {
5    return a + b
6}
7
8// calculator_test.go
9package main
10
11import "testing"
12
13func TestAdd(t *testing.T) {
14    result := Add(2, 3)
15    if result != 5 {
16        t.Errorf("Add(2, 3) = %d; want 5", result)
17    }
18}

1# Все тесты
2go test ./...
3
4# Конкретный пакет
5go test ./pkg/calculator
6
7# С verbose выводом
8go test -v ./...
9
10# С фильтром
11go test -run TestAdd ./...
12
13# Тесты с build tags
14go test -tags=integration ./...

1func TestAdd(t *testing.T) {
2    tests := []struct {
3        name     string
4        a, b     int
5        expected int
6    }{
7        {"positive numbers", 2, 3, 5},
8        {"negative numbers", -1, -1, -2},
9        {"zero", 0, 0, 0},
10        {"mixed", -5, 5, 0},
11    }
12
13    for _, tt := range tests {
14        t.Run(tt.name, func(t *testing.T) {
15            result := Add(tt.a, tt.b)
16            if result != tt.expected {
17                t.Errorf("Add(%d, %d) = %d; want %d",
18                    tt.a, tt.b, result, tt.expected)
19            }
20        })
21    }
22}

1func TestDivide(t *testing.T) {
2    tests := []struct {
3        name      string
4        a, b      float64
5        expected  float64
6        wantError bool
7    }{
8        {"normal division", 10, 2, 5, false},
9        {"by zero", 10, 0, 0, true},
10    }
11
12    for _, tt := range tests {
13        t.Run(tt.name, func(t *testing.T) {
14            result, err := Divide(tt.a, tt.b)
15
16            if tt.wantError {
17                if err == nil {
18                    t.Error("expected error, got nil")
19                }
20                return
21            }
22
23            if err != nil {
24                t.Fatalf("unexpected error: %v", err)
25            }
26
27            if result != tt.expected {
28                t.Errorf("Divide(%v, %v) = %v; want %v",
29                    tt.a, tt.b, result, tt.expected)
30            }
31        })
32    }
33}

1func TestCreateUser(t *testing.T) {
2    tests := []struct {
3        name    string
4        input   CreateUserRequest
5        wantErr error
6    }{
7        {
8            name:  "valid user",
9            input: CreateUserRequest{Name: "Alice", Email: "alice@test.com"},
10            wantErr: nil,
11        },
12        {
13            name:  "empty name",
14            input: CreateUserRequest{Name: "", Email: "alice@test.com"},
15            wantErr: ErrEmptyName,
16        },
17    }
18
19    for _, tt := range tests {
20        t.Run(tt.name, func(t *testing.T) {
21            _, err := CreateUser(tt.input)
22            if !errors.Is(err, tt.wantErr) {
23                t.Errorf("got error %v, want %v", err, tt.wantErr)
24            }
25        })
26    }
27}

1// repository.go
2type UserRepository interface {
3    GetByID(id int) (*User, error)
4    Create(user *User) error
5    Update(user *User) error
6    Delete(id int) error
7}
8
9// Mock реализация
10type MockUserRepository struct {
11    Users map[int]*User
12}
13
14func NewMockUserRepository() *MockUserRepository {
15    return &MockUserRepository{Users: make(map[int]*User)}
16}
17
18func (m *MockUserRepository) GetByID(id int) (*User, error) {
19    user, ok := m.Users[id]
20    if !ok {
21        return nil, ErrUserNotFound
22    }
23    return user, nil
24}
25
26func (m *MockUserRepository) Create(user *User) error {
27    m.Users[user.ID] = user
28    return nil
29}

1func TestUserService_GetUser(t *testing.T) {
2    repo := NewMockUserRepository()
3    repo.Users[1] = &User{ID: 1, Name: "Alice"}
4
5    service := NewUserService(repo)
6
7    t.Run("found", func(t *testing.T) {
8        user, err := service.GetUser(1)
9        if err != nil {
10            t.Fatalf("unexpected error: %v", err)
11        }
12        if user.Name != "Alice" {
13            t.Errorf("got name %s, want Alice", user.Name)
14        }
15    })
16
17    t.Run("not found", func(t *testing.T) {
18        _, err := service.GetUser(999)
19        if err != ErrUserNotFound {
20            t.Errorf("got error %v, want ErrUserNotFound", err)
21        }
22    })
23}

1func BenchmarkAdd(b *testing.B) {
2    for i := 0; i < b.N; i++ {
3        Add(2, 3)
4    }
5}
6
7func BenchmarkConcatenation(b *testing.B) {
8    for i := 0; i < b.N; i++ {
9        s := ""
10        for j := 0; j < 1000; j++ {
11            s += "a"
12        }
13    }
14}
15
16func BenchmarkStringBuilder(b *testing.B) {
17    for i := 0; i < b.N; i++ {
18        var builder strings.Builder
19        for j := 0; j < 1000; j++ {
20            builder.WriteString("a")
21        }
22        _ = builder.String()
23    }
24}

1# Запуск benchmarks
2go test -bench=. ./...
3
4# С памятью
5go test -bench=. -benchmem ./...
6
7# Конкретный benchmark
8go test -bench=BenchmarkAdd ./...

1//go:build integration
2
3package main
4
5import (
6    "testing"
7    "database/sql"
8    _ "github.com/lib/pq"
9)
10
11func TestIntegration_CreateUser(t *testing.T) {
12    db, _ := sql.Open("postgres", testConnStr)
13    defer db.Close()
14
15    // Создание пользователя
16    id, err := CreateUser(db, "Test", "test@test.com")
17    if err != nil {
18        t.Fatalf("failed to create user: %v", err)
19    }
20
21    // Проверка
22    user, err := GetUser(db, id)
23    if err != nil {
24        t.Fatalf("failed to get user: %v", err)
25    }
26
27    if user.Name != "Test" {
28        t.Errorf("got name %s, want Test", user.Name)
29    }
30}

1// Плохо
2func TestSomething(t *testing.T) {}
3
4// Хорошо
5func TestAdd_ReturnsSumOfTwoNumbers(t *testing.T) {}
6func TestDivide_ReturnsErrorOnZeroDivisor(t *testing.T) {}

1func TestAdd_EdgeCases(t *testing.T) {
2    tests := []struct {
3        name     string
4        a, b     int
5        expected int
6    }{
7        {"max int overflow", math.MaxInt, 1, math.MinInt}, // Ожидаем overflow
8        {"min int", math.MinInt, 0, math.MinInt},
9    }
10    // ...
11}