Тестирование в Go: от табличных тестов до интеграционных сценариев

package math

import "testing"

func Abs(n int) int {
	if n < 0 {
		return -n
	}
	return n
}

func TestAbs(t *testing.T) {
	result := Abs(-5)
	if result != 5 {
		t.Errorf("Abs(-5) = %d, ожидали 5", result)
	}
}

$ go test ./...
ok  	mypackage	0.003s

$ go test -v ./...
=== RUN   TestAbs
--- PASS: TestAbs (0.00s)
PASS
ok  	mypackage	0.003s

$ go test -v -run TestAbs ./...

func TestExample(t *testing.T) {
	conn, err := connect()
	if err != nil {
		t.Fatalf("не удалось подключиться: %v", err) // Дальше проверять нечего
	}

	result := conn.Query("SELECT 1")
	if result != 1 {
		t.Errorf("Query() = %d, ожидали 1", result) // Можно продолжать
	}

	result2 := conn.Query("SELECT 2")
	if result2 != 2 {
		t.Errorf("Query() = %d, ожидали 2", result2) // Увидим оба провала
	}
}

func ExampleAbs() {
	fmt.Println(Abs(-5))
	fmt.Println(Abs(0))
	fmt.Println(Abs(3))
	// Output:
	// 5
	// 0
	// 3
}

$ go test -v -run ExampleAbs
=== RUN   ExampleAbs
--- PASS: ExampleAbs (0.00s)
PASS

package validation

import (
	"regexp"
	"testing"
)

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`)

func ValidateEmail(email string) bool {
	if len(email) > 254 {
		return false
	}
	return emailRegex.MatchString(email)
}

func TestValidateEmail(t *testing.T) {
	tests := []struct {
		name  string
		email string
		want  bool
	}{
		{name: "валидный email", email: "user@example.com", want: true},
		{name: "с точкой в имени", email: "user.name@example.com", want: true},
		{name: "с плюсом", email: "user+tag@example.com", want: true},
		{name: "без @", email: "userexample.com", want: false},
		{name: "без домена", email: "user@", want: false},
		{name: "пустая строка", email: "", want: false},
		{name: "пробелы", email: "user @example.com", want: false},
		{name: "слишком длинный", email: string(make([]byte, 255)) + "@example.com", want: false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := ValidateEmail(tt.email)
			if got != tt.want {
				t.Errorf("ValidateEmail(%q) = %v, ожидали %v", tt.email, got, tt.want)
			}
		})
	}
}

$ go test -v -run TestValidateEmail
=== RUN   TestValidateEmail
=== RUN   TestValidateEmail/валидный_email
=== RUN   TestValidateEmail/с_точкой_в_имени
=== RUN   TestValidateEmail/с_плюсом
=== RUN   TestValidateEmail/без_@
=== RUN   TestValidateEmail/без_домена
=== RUN   TestValidateEmail/пустая_строка
=== RUN   TestValidateEmail/пробелы
=== RUN   TestValidateEmail/слишком_длинный
--- PASS: TestValidateEmail (0.00s)
    --- PASS: TestValidateEmail/валидный_email (0.00s)
    --- PASS: TestValidateEmail/с_точкой_в_имени (0.00s)
    --- PASS: TestValidateEmail/с_плюсом (0.00s)
    --- PASS: TestValidateEmail/без_@ (0.00s)
    --- PASS: TestValidateEmail/без_домена (0.00s)
    --- PASS: TestValidateEmail/пустая_строка (0.00s)
    --- PASS: TestValidateEmail/пробелы (0.00s)
    --- PASS: TestValidateEmail/слишком_длинный (0.00s)
PASS

$ go test -v -run "TestValidateEmail/без_@"

func TestUserService(t *testing.T) {
	svc := NewUserService(newMockRepo())

	t.Run("создание", func(t *testing.T) {
		user, err := svc.Create("alice", "alice@example.com")
		if err != nil {
			t.Fatalf("Create: %v", err)
		}
		if user.Name != "alice" {
			t.Errorf("Name = %q, ожидали %q", user.Name, "alice")
		}
	})

	t.Run("дубликат email", func(t *testing.T) {
		_, err := svc.Create("bob", "alice@example.com")
		if err == nil {
			t.Error("ожидали ошибку при дублировании email")
		}
	})

	t.Run("поиск по ID", func(t *testing.T) {
		user, err := svc.FindByID(1)
		if err != nil {
			t.Fatalf("FindByID: %v", err)
		}
		if user.Email != "alice@example.com" {
			t.Errorf("Email = %q, ожидали %q", user.Email, "alice@example.com")
		}
	})
}

func TestValidateEmail_Parallel(t *testing.T) {
	tests := []struct {
		name  string
		email string
		want  bool
	}{
		{name: "валидный", email: "user@example.com", want: true},
		{name: "без @", email: "invalid", want: false},
		{name: "пустой", email: "", want: false},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			got := ValidateEmail(tt.email)
			if got != tt.want {
				t.Errorf("ValidateEmail(%q) = %v, ожидали %v", tt.email, got, tt.want)
			}
		})
	}
}

$ go test -race -v ./...

func assertEqual(t *testing.T, got, want int) {
	t.Helper()
	if got != want {
		t.Errorf("получили %d, ожидали %d", got, want)
	}
}

func TestCalculation(t *testing.T) {
	assertEqual(t, Abs(-5), 5)   // При ошибке укажет на эту строку
	assertEqual(t, Abs(3), 3)
}

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

	db, err := sql.Open("postgres", "postgres://localhost/testdb?sslmode=disable")
	if err != nil {
		t.Fatalf("не удалось подключиться к БД: %v", err)
	}

	// Будет вызвано после завершения теста
	t.Cleanup(func() {
		db.Exec("DELETE FROM users WHERE email LIKE '%@test.example.com'")
		db.Close()
	})

	return db
}

func TestCreateUser(t *testing.T) {
	db := setupTestDB(t)

	// Работаем с БД, cleanup вызовется автоматически
	_, err := db.Exec("INSERT INTO users (email) VALUES ($1)", "alice@test.example.com")
	if err != nil {
		t.Fatalf("INSERT: %v", err)
	}
}

func TestWriteConfig(t *testing.T) {
	dir := t.TempDir() // Удалится после теста

	path := filepath.Join(dir, "config.json")
	err := WriteConfig(path, Config{Port: 8080})
	if err != nil {
		t.Fatalf("WriteConfig: %v", err)
	}

	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("ReadFile: %v", err)
	}

	if !strings.Contains(string(data), "8080") {
		t.Error("конфиг не содержит порт 8080")
	}
}

mypackage/
├── parser.go
├── parser_test.go
└── testdata/
    ├── valid_input.json
    ├── malformed.json
    └── golden/
        └── expected_output.json

func TestParseConfig(t *testing.T) {
	data, err := os.ReadFile("testdata/valid_input.json")
	if err != nil {
		t.Fatalf("не удалось прочитать фикстуру: %v", err)
	}

	got, err := ParseConfig(data)
	if err != nil {
		t.Fatalf("ParseConfig: %v", err)
	}

	if got.Port != 8080 {
		t.Errorf("Port = %d, ожидали 8080", got.Port)
	}
}

var update = flag.Bool("update", false, "обновить golden files")

func TestRender(t *testing.T) {
	got := Render(inputData)

	goldenPath := "testdata/golden/expected_output.json"

	if *update {
		os.WriteFile(goldenPath, got, 0644)
		return
	}

	want, err := os.ReadFile(goldenPath)
	if err != nil {
		t.Fatalf("не удалось прочитать golden file: %v", err)
	}

	if !bytes.Equal(got, want) {
		t.Errorf("результат не совпадает с golden file:\nполучили:\n%s\nожидали:\n%s", got, want)
	}
}

$ go test -run TestRender -update

func FuzzValidateEmail(f *testing.F) {
	// Seed-корпус: начальные примеры, от которых фаззер отталкивается
	f.Add("user@example.com")
	f.Add("")
	f.Add("@")
	f.Add("a@b.c")
	f.Add(string(make([]byte, 300)))

	f.Fuzz(func(t *testing.T, email string) {
		// Функция не должна паниковать ни на каком входе
		ValidateEmail(email)
	})
}

$ go test -fuzz FuzzValidateEmail
fuzz: elapsed: 0s, gathering baseline coverage: 0/5 completed
fuzz: elapsed: 0s, gathering baseline coverage: 5/5 completed, now fuzzing with 8 workers
fuzz: elapsed: 3s, execs: 352781 (117573/sec), new interesting: 12 (total: 17)
^C

$ go test -fuzz FuzzValidateEmail -fuzztime=30s

func FuzzJSONRoundTrip(f *testing.F) {
	f.Add("Alice", "alice@example.com", 30)

	f.Fuzz(func(t *testing.T, name, email string, age int) {
		original := User{Name: name, Email: email, Age: age}

		data, err := json.Marshal(original)
		if err != nil {
			t.Skip("невалидный вход для JSON")
		}

		var decoded User
		if err := json.Unmarshal(data, &decoded); err != nil {
			t.Fatalf("Unmarshal не смог прочитать то, что Marshal записал: %v", err)
		}

		if original != decoded {
			t.Errorf("round-trip изменил данные:\nдо:    %+v\nпосле: %+v", original, decoded)
		}
	})
}

func Retry(attempts int, base time.Duration, fn func() error) error {
	var err error
	for i := 0; i < attempts; i++ {
		if err = fn(); err == nil {
			return nil
		}
		if i < attempts-1 {
			time.Sleep(base << i)
		}
	}
	return errors.New("все попытки исчерпаны: " + err.Error())
}

func TestRetry_Backoff(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		start := time.Now()
		calls := 0

		err := Retry(4, time.Second, func() error {
			calls++
			return errors.New("сервис недоступен")
		})

		if err == nil {
			t.Fatal("ожидали ошибку после четырёх попыток")
		}
		if calls != 4 {
			t.Errorf("вызовов = %d, ожидали 4", calls)
		}
		// Паузы 1s + 2s + 4s между четырьмя попытками.
		if got := time.Since(start); got != 7*time.Second {
			t.Errorf("прошло %v, ожидали 7s", got)
		}
	})
}

$ go test -v -run TestRetry_Backoff ./...
=== RUN   TestRetry_Backoff
--- PASS: TestRetry_Backoff (0.00s)

func TestCache_Expiration(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		c := NewCache(5 * time.Minute)
		c.Set("user:1", "Alice")

		time.Sleep(5*time.Minute - time.Nanosecond)
		if _, ok := c.Get("user:1"); !ok {
			t.Fatal("значение пропало раньше времени")
		}

		time.Sleep(time.Nanosecond)
		if _, ok := c.Get("user:1"); ok {
			t.Fatal("значение осталось после истечения TTL")
		}
	})
}

func TestWorker_StopsOnCancel(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		ctx, cancel := context.WithCancel(t.Context())
		stopped := false

		go func() {
			<-ctx.Done()
			stopped = true
		}()

		synctest.Wait()
		if stopped {
			t.Fatal("воркер остановился до отмены контекста")
		}

		cancel()
		synctest.Wait()
		if !stopped {
			t.Fatal("воркер не остановился после отмены контекста")
		}
	})
}

synctest.Sleep(d)
// эквивалентно
time.Sleep(d)
synctest.Wait()

func TestSleepVsWait(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		var got string
		go func() {
			time.Sleep(time.Second)
			got = "готово"
		}()

		time.Sleep(time.Second)
		t.Log("значение записано:", got == "готово")
	})
}

func TestHeartbeat(t *testing.T) {
	synctest.Test(t, func(t *testing.T) {
		ctx, cancel := context.WithCancel(t.Context())
		defer cancel()

		beats := 0
		go func() {
			for {
				select {
				case <-ctx.Done():
					return
				case <-time.After(time.Second):
					beats++
				}
			}
		}()

		synctest.Sleep(3 * time.Second)
		if beats != 3 {
			t.Errorf("ударов = %d, ожидали 3", beats)
		}
	})
}

// Интерфейс репозитория
type UserRepository interface {
	FindByID(id int) (*User, error)
	Save(user *User) error
}

// Сервис принимает интерфейс
type UserService struct {
	repo UserRepository
}

func NewUserService(repo UserRepository) *UserService {
	return &UserService{repo: repo}
}

func (s *UserService) GetUser(id int) (*User, error) {
	user, err := s.repo.FindByID(id)
	if err != nil {
		return nil, fmt.Errorf("поиск пользователя: %w", err)
	}
	return user, nil
}

type mockUserRepo struct {
	users map[int]*User
	err   error
}

func (m *mockUserRepo) FindByID(id int) (*User, error) {
	if m.err != nil {
		return nil, m.err
	}
	user, ok := m.users[id]
	if !ok {
		return nil, fmt.Errorf("пользователь %d не найден", id)
	}
	return user, nil
}

func (m *mockUserRepo) Save(user *User) error {
	if m.err != nil {
		return m.err
	}
	m.users[user.ID] = user
	return nil
}

func TestGetUser(t *testing.T) {
	repo := &mockUserRepo{
		users: map[int]*User{
			1: {ID: 1, Name: "Alice", Email: "alice@example.com"},
		},
	}
	svc := NewUserService(repo)

	t.Run("существующий пользователь", func(t *testing.T) {
		user, err := svc.GetUser(1)
		if err != nil {
			t.Fatalf("GetUser: %v", err)
		}
		if user.Name != "Alice" {
			t.Errorf("Name = %q, ожидали %q", user.Name, "Alice")
		}
	})

	t.Run("несуществующий пользователь", func(t *testing.T) {
		_, err := svc.GetUser(999)
		if err == nil {
			t.Error("ожидали ошибку для несуществующего пользователя")
		}
	})

	t.Run("ошибка репозитория", func(t *testing.T) {
		repo := &mockUserRepo{err: fmt.Errorf("connection refused")}
		svc := NewUserService(repo)

		_, err := svc.GetUser(1)
		if err == nil {
			t.Error("ожидали ошибку при сбое репозитория")
		}
	})
}

import (
	"testing"

	"github.com/stretchr/testify/mock"
)

type MockUserRepo struct {
	mock.Mock
}

func (m *MockUserRepo) FindByID(id int) (*User, error) {
	args := m.Called(id)
	if args.Get(0) == nil {
		return nil, args.Error(1)
	}
	return args.Get(0).(*User), args.Error(1)
}

func (m *MockUserRepo) Save(user *User) error {
	args := m.Called(user)
	return args.Error(0)
}

func TestGetUser_Testify(t *testing.T) {
	repo := new(MockUserRepo)

	// Настраиваем ожидаемое поведение
	repo.On("FindByID", 1).Return(&User{ID: 1, Name: "Alice"}, nil)
	repo.On("FindByID", 999).Return(nil, fmt.Errorf("не найден"))

	svc := NewUserService(repo)

	user, err := svc.GetUser(1)
	if err != nil {
		t.Fatalf("GetUser: %v", err)
	}
	if user.Name != "Alice" {
		t.Errorf("Name = %q, ожидали %q", user.Name, "Alice")
	}

	// Проверяем, что все ожидаемые вызовы произошли
	repo.AssertExpectations(t)
}

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestOrderCreation(t *testing.T) {
	svc := NewOrderService(newMockDB())

	// require для setup — если заказ не создался, проверять нечего
	order, err := svc.CreateOrder(CreateOrderRequest{
		UserID: 1,
		Items:  []Item{{ProductID: 42, Quantity: 2}},
	})
	require.NoError(t, err)
	require.NotNil(t, order)

	// assert для проверок — увидим все ошибки за один прогон
	assert.Equal(t, 1, order.UserID)
	assert.Equal(t, StatusPending, order.Status)
	assert.Len(t, order.Items, 1)
	assert.False(t, order.CreatedAt.IsZero())
}

package api

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
)

func HealthHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
}

func TestHealthHandler(t *testing.T) {
	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	rec := httptest.NewRecorder()

	HealthHandler(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("статус %d, ожидали %d", rec.Code, http.StatusOK)
	}

	var body map[string]string
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatalf("не удалось распарсить ответ: %v", err)
	}
	if body["status"] != "ok" {
		t.Errorf("status = %q, ожидали %q", body["status"], "ok")
	}
}

func TestGitHubClient(t *testing.T) {
	// Поднимаем тестовый сервер, который имитирует GitHub API
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/users/octocat" {
			http.NotFound(w, r)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]interface{}{
			"login":      "octocat",
			"name":       "The Octocat",
			"public_repos": 8,
		})
	}))
	defer server.Close()

	// Подставляем URL тестового сервера вместо реального
	client := NewGitHubClient(server.URL)

	user, err := client.GetUser("octocat")
	if err != nil {
		t.Fatalf("GetUser: %v", err)
	}
	if user.Login != "octocat" {
		t.Errorf("Login = %q, ожидали %q", user.Login, "octocat")
	}
	if user.PublicRepos != 8 {
		t.Errorf("PublicRepos = %d, ожидали %d", user.PublicRepos, 8)
	}
}

$ go test -cover ./...
ok  	mypackage	0.003s	coverage: 78.4% of statements

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

$ go test -race -cover -count=1 ./...

func TestWithExternalAPI(t *testing.T) {
	apiKey := os.Getenv("API_KEY")
	if apiKey == "" {
		t.Skip("API_KEY не задан, пропускаем")
	}

	// ... тест с реальным API
}

func TestSlowIntegration(t *testing.T) {
	if testing.Short() {
		t.Skip("пропускаем в short-режиме")
	}

	// ... тест, который работает 10 секунд
}

# Быстрый прогон при разработке
$ go test -short ./...

# Полный прогон в CI
$ go test ./...

//go:build integration

package storage

import (
	"database/sql"
	"os"
	"testing"

	_ "github.com/lib/pq"
)

var testDB *sql.DB

func TestMain(m *testing.M) {
	// Setup: подключаемся к тестовой БД
	dsn := os.Getenv("TEST_DATABASE_URL")
	if dsn == "" {
		dsn = "postgres://localhost/testdb?sslmode=disable"
	}

	var err error
	testDB, err = sql.Open("postgres", dsn)
	if err != nil {
		panic("не удалось подключиться к БД: " + err.Error())
	}

	// Запускаем тесты
	code := m.Run()

	// Teardown: очищаем и закрываем
	testDB.Exec("DELETE FROM users WHERE email LIKE '%@test.example.com'")
	testDB.Close()

	os.Exit(code)
}

func TestUserRepository_Create(t *testing.T) {
	repo := NewUserRepository(testDB)

	user, err := repo.Create("test@test.example.com", "Test User")
	if err != nil {
		t.Fatalf("Create: %v", err)
	}

	t.Cleanup(func() {
		testDB.Exec("DELETE FROM users WHERE id = $1", user.ID)
	})

	found, err := repo.FindByID(user.ID)
	if err != nil {
		t.Fatalf("FindByID: %v", err)
	}
	if found.Email != "test@test.example.com" {
		t.Errorf("Email = %q, ожидали %q", found.Email, "test@test.example.com")
	}
}

$ go test -tags=integration ./...