БИ @goproglib
Showing posts older than #7304 · Back to latest
type Box[T any] struct{ v T }
func (b Box[T]) Map[U any](f func(T) U) Box[U] {
return Box[U]{f(b.v)}
}encoding/json/v2 и encoding/json/jsontext. Старый encoding/json теперь работает поверх v2. Поведение сохранили, но разбор JSON стал заметно быстрее, а кодирование осталось примерно на том же уровне. v2 строже по умолчанию, отвергает битый UTF-8 и дублирующиеся ключи в объекте. GOEXPERIMENT=nojsonv2.uuid генерирует и парсит UUID. Можно выкинуть одну внешнюю зависимость из проекта.goroutineleak доехал из эксперимента в стабильную версию и ловит горутины, навсегда заблокированные на канале или мьютексе. simd для портируемых векторных операций, включается через GOEXPERIMENT=simd. crypto/mldsa по FIPS 204 и поддержку их в crypto/tls и crypto/x509. В strings и bytes появилась CutLast, в net/url методы Clone. time теперь всегда небуферизованные, настройку asynctimerchan убрали навсегда. И минимум для macOS поднялся до Ventura 13.go install golang.org/dl/go1.27rc1@latest
go1.27rc1 download
type UserRepository interface {
GetByID(ctx context.Context, id string) (*User, error)
Create(ctx context.Context, u *User) error
Update(ctx context.Context, u *User) error
Delete(ctx context.Context, id string) error
}
// и мок на 120 строк, который расходится с реальной
// реализацией в тот же миг, когда кто-то добавил методpgx между pgx.ErrNoRows и реальной ошибкой скана. И он даёт ложную уверенность, тесты зелёные, а боевые запросы кривые.testcontainers-go поднимает реальный Postgres прямо в CI. Код, сгенерированный sqlc, типизирован и корректен по построению. func TestCreateMember(t *testing.T) {
ctx := context.Background()
db := testutil.NewPostgresContainer(t) // реальный postgres, реальная схема
q := db_gen.New(db)
member, err := q.CreateMember(ctx, db_gen.CreateMemberParams{
FullName: "Witty",
Phone: "+254700000000",
})
require.NoError(t, err)
require.Equal(t, "Witty", member.FullName)
}net/http хранил состояние запроса в горутине по ID, сервер не мог бы распараллелить обработку одного запроса между несколькими горутинами. Вся архитектура стала бы жёстче.runtime.Stack и парсинг вывода. Это работает, но Go-команда считает такой подход антипаттерном: он хрупкий, медленный и ломается при изменении формата стека.context.Context:func worker(ctx context.Context, jobs <-chan int, results chan<- int) {
for {
select {
case j, ok := <-jobs:
if !ok {
return
}
results <- process(ctx, j)
case <-ctx.Done():
return
}
}
}
net/http, без фреймворка. Java на Helidon SE с виртуальными потоками, в двух вариантах. Обычный JVM от Oracle JDK 26 и тот же JDK с AOT-кэшем Leyden. Helidon SE держит сервис маленьким, так что сравнение не «Go против монстра-фреймворка».ctx добавляют в сигнатуру каждой функции, включая чистые функции без всякого ввода вывода, просто потому что так сказал линтер или комментарий в PR:// Этой функции context не нужен
func calculateInstallments(principal float64, rate float64, months int) []Installment {
// чистая математика, нет I/O, нет горутин
}
context.WithValue, чего делать не стоит.«Мультиагентные системы: почему большинство архитектур переусложнены»
mock.go и наметили разбиение тестов на слои. Теперь покажем сами тесты двух слоёв и честно разберём, чем платим за такую структуру.mock.go, поэтому тесты гоняются целиком в памяти и работают очень быстро. func TestAuthServiceLogin(t *testing.T) {
t.Run("login credentials", func(t *testing.T) {
testAuthRepo.GetUsernameOrEmailFunc = func(ctx context.Context, username string) (*models.Users, error) {
hash, _ := bcrypt.GenerateFromPassword([]byte("!Abc1234"), bcrypt.DefaultCost)
return &models.Users{ID: 1, Username: "test_account", Password: string(hash)}, nil
}
req := auth.LoginRequest{Username: "rdev", Password: "!Abc1234"}
_, err := testAuthSvc.Login(context.Background(), req)
if err != nil {
t.Errorf("Expected no error, got %v", err)
}
})
}net/http/httptest и использует моки сервиса, чтобы не дёргать реальную логику. Под проверкой статус коды, сериализация JSON, параметры запроса, заголовки, работа мидлварей вроде rate limiter. func TestAuthHandlerLogin(t *testing.T) {
tests := []struct {
name string
requestBody any
expectedStatus int
}{
{"complete credentials", loginRequest{"rdev", "!Abc1234"}, http.StatusOK},
{"no password", loginRequest{"rdev", ""}, http.StatusBadRequest},
{"password too short", loginRequest{"rdev", "1234"}, http.StatusBadRequest},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx, w := helpers.SetupJSONTestContext(t, http.MethodPost, "/login", tt.requestBody)
testAuthHandler.Login(ctx)
if w.Code != tt.expectedStatus {
t.Errorf("Login() status = %d, want %d", w.Code, tt.expectedStatus)
}
})
}
}mock.go придётся править руками, если не подключить генератор вроде mockery.
restic — это открытая программа бэкапа на Go, которая работает на Linux, macOS, Windows, а также FreeBSD и OpenBSD. На GitHub у проекта около 34 тысяч звёзд.restic init --repo /tmp/backup
restic --repo /tmp/backup backup ~/work
restic restore, либо смонтировать репозиторий через fuse командой restic mount и ходить по файлам прошлых снапшотов как по обычной папке.rclone подключается ещё множество сервисов.*_test.go. В него свалено всё подряд. Настройка окружения, рукописные моки репозитория и сервиса, проверка бизнес логики, симуляция HTTP. Сначала удобно, потом файл пухнет до тысяч строк. В этой части разберём, чем это плохо и как вынести моки в одно место.package_test/
mock.go // общие моки сервиса и репозитория
*_service_test.go // юнит тесты бизнес логики
*_handler_test.go // HTTP, роутинг, валидация
mock.go. Это единый источник правды для тестовых дублей, и именно вынос моков убирает циклические импорты:type MockAuthRepository struct {
GetUsernameOrEmailFunc func(ctx context.Context, username string) (*models.Users, error)
RegisterFunc func(ctx context.Context, user *models.Users) error
}
func (m *MockAuthRepository) GetUsernameOrEmail(ctx context.Context, username string) (*models.Users, error) {
if m.GetUsernameOrEmailFunc != nil {
return m.GetUsernameOrEmailFunc(ctx, username)
}
return &models.Users{}, nil
}mock.go и разбиением тестов на слои. В части 2 покажем тесты бизнес логики и HTTP слоя, а также трейдоффы подхода.
nums и число pivot. Нужно переставить элементы так, чтобы сначала шли все числа меньше опорного, затем равные ему, потом большие.pivot;func pivotArray(nums []int, pivot int) []int {
res := make([]int, 0, len(nums))
for _, v := range nums {
if v < pivot {
res = append(res, v)
}
}
for _, v := range nums {
if v == pivot {
res = append(res, v)
}
}
for _, v := range nums {
if v > pivot {
res = append(res, v)
}
}
return res
}func pivotArray(nums []int, pivot int) []int {
n := len(nums)
res := make([]int, n)
left, right := 0, n-1
for i, j := 0, n-1; i < n; i, j = i+1, j-1 {
if nums[i] < pivot {
res[left] = nums[i]
left++
}
if nums[j] > pivot {
res[right] = nums[j]
right--
}
}
for left <= right {
res[left] = pivot
left++
}
return res
}i бежит вперёд и кладёт меньшие числа в левую часть — в исходном порядке;j бежит назад и кладёт большие числа в правую часть.j движется с конца, поэтому более поздние большие элементы попадают правее — относительный порядок сохраняется.left и right остаётся под равные pivot. Его и дозаполняем.server.Shutdown() ждёт текущие запросы, но не закрывает входящий трафик мгновенно. Между сигналом и фактической остановкой сервер продолжает принимать новые соединения. При высокой нагрузке это окно создаёт проблемы.package main
import (
"context"
"fmt"
"net/http"
"os"
"os/signal"
"sync/atomic"
"syscall"
"time"
)
var isShuttingDown int32
func rejectMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if atomic.LoadInt32(&isShuttingDown) == 1 {
http.Error(w, "server is shutting down", http.StatusServiceUnavailable)
return
}
next.ServeHTTP(w, r)
})
}
func handler(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("id")
fmt.Printf("START %s\n", id)
time.Sleep(5 * time.Second)
fmt.Printf("DONE %s\n", id)
w.Write([]byte("COMPLETED!"))
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", handler)
server := &http.Server{
Addr: ":8080",
Handler: rejectMiddleware(mux),
}
go func() {
fmt.Println("server started at :8080")
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
panic(err)
}
}()
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
<-ctx.Done()
fmt.Println("shutdown signal received")
atomic.StoreInt32(&isShuttingDown, 1)
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
server.Shutdown(shutdownCtx)
fmt.Println("graceful shutdown complete")
}
isShuttingDown = 1. rejectMiddleware проверяет этот флаг перед каждым запросом. Если флаг поднят, новый клиент получает 503 Service Unavailable. Уже выполняющиеся обработчики продолжают работу и завершаются штатно.atomic.LoadInt32 и atomic.StoreInt32 нужны потому, что флаг читается и пишется из разных горутин. Без атомарных операций здесь была бы гонка данных.
TestCartActionHandler вообще не запускался. Не падал, не скипался, его просто не было в списке из 144 тестов. В первой строке файла, над объявлением пакета, стояла строка, которую все приняли за комментарий://go:build integration
.go файла, которая говорит тулчейну, включать ли файл в конкретную сборку. Работает как условный шлюз на уровне файла. Когда вы запускаете go build или go test, тулчейн проверяет ограничение каждого файла против текущего контекста сборки. package, до импортов://go:build <выражение>
//go: директивы). Префикс ровно //go:build, без пробела между // и go. Выражение булево, собирается из имён тегов через &&, ||, ! и скобки.-tags. Не попросили, файла как бы не существует.//go:build tagname // истинно, когда задан -tags tagname
//go:build !tagname // истинно, когда tagname НЕ задан
//go:build tagA && tagB // оба заданы
//go:build tagA || tagB // задан любой из двух
//go:build (tagA || tagB) && !tagC // группировка скобками
-tags у любой go команды:go build -tags linux ./...
go test -tags integration ./...
go run -tags debug main.go
go test -tags integration,gpu ./...
go build, go test, go run и go vet. То, что вы передаёте, добавляется в активный набор тегов только для этого вызова и не сохраняется.GOOS, без switch runtime.GOOS и без мёртвого кода в бинаре://go:build linux
func watch(path string) { /* inotify */ }
//go:build darwin
func watch(path string) { /* kqueue */ }
os.RemoveAll три отдельных файла, каждый со своим тегом под unix, windows и фолбэк на остальное.//go:build integration
package repository_test
func TestUserRepository_Create(t *testing.T) { ... } // ходит в реальный Postgres
gpu лежит реализация на CUDA, без тега чистый Go фолбэк. Под тегом debug живут дампы состояния, которые в прод бинарь не попадают вообще.//go:build integration, а команда make test запускала go test без -tags integration. Файл молча исключался из прогона, и его тесты не запускались ни разу с момента старта проекта. Скелет теста скопировали из соседнего проекта, где make test сознательно прокидывал нужный тег. Тот, кто копировал, принял первую строку за комментарий. Ревьюер тоже не заметил.--- FAIL: TestHandlePaymentPartyResponse (0.31s)
--- FAIL: TestUserSignatureValidation (0.18s)
...
FAIL: 9 tests failed, 208 tests total
http.Server.Shutdownserver.Shutdown().http.Server явно и используем его метод Shutdown:package main
import (
"context"
"fmt"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Println("handling request...")
time.Sleep(5 * time.Second)
fmt.Fprintln(w, "done")
}
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", handler)
server := &http.Server{
Addr: ":8080",
Handler: mux,
}
go func() {
fmt.Println("server started at :8080")
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
panic(err)
}
}()
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
<-ctx.Done()
fmt.Println("shutdown signal received")
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
server.Shutdown(shutdownCtx)
fmt.Println("graceful shutdown complete")
}
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
server.Shutdown(shutdownCtx)
server.Shutdown() останавливает приём новых соединений и ждёт, пока текущие запросы завершатся. Таймаут контекста страхует от зависания — если через 10 секунд что-то ещё не завершилось, процесс всё равно выйдет.Shutdown. В это время сервер всё ещё принимает новые соединения. При высокой нагрузке это может привести к непредсказуемому поведению — часть запросов получит ответ, часть будет оборвана.server.Shutdown() решает главную проблему — in-flight запросы дожидаются завершения. Для большинства сервисов этого достаточно. Но если нужна полная управляемость трафиком во время shutdown, нужен ещё один слой.
