Автоматизация тестирования на Go: стратегия и реализация с нуля

• почему автотесты на Go — это не просто альтернативный стек, а способ сделать тесты быстрее, стабильнее и ближе к коду;

• как изолировать внешние зависимости через моки и не ломать тесты при каждом изменении API;

• как корректно тестировать Kafka и БД, чтобы ловить реальные интеграционные ошибки;

• как встроить всё это в CI/CD и получить быстрый, предсказуемый фидбек перед релизом.

• fly-broker — gRPC-сервис бронирования
  
• avia-service —HTTP-сервис, выпускающий билеты
  
• PostgreSQL
  
• Kafka (через выгрузку из Outbox)

go get github.com/ozontech/allure-go/pkg/allure
go get github.com/ozontech/allure-go/pkg/framework

type CreateOrderSuite struct {
 setup.TestSuite
   ParamCreateOrderPositiveTestData []CreateOrderPositiveTestData
    ParamCreateOrderNegativeTestData []CreateOrderNegativeTestData
}
func (s *CreateOrderSuite) BeforeAll(t provider.T) {
      s.Setup(t)
        s.ParamCreateOrderPositiveTestData = GetCreateOrderPositiveTestData
       s.ParamCreateOrderNegativeTestData = GetCreateOrderNegativeTestData
}
// SuiteRunner запускает все тесты из сьюта CreateOrderSuite
func TestCreateOrderSuiteRunner(t *testing.T) {
    suite.RunNamedSuite(t, constants.CreateOrderSuite, new(CreateOrderSuite))
}
// Параметризованные тесты
func (s *CreateOrderSuite) TableTestCreateOrderPositiveTestData(t provider.T, data CreateOrderPositiveTestData) {
      t.Parallel()
      t.Title(data.testName)
    t.Description("Создаем заказ. После сверяем статус заказа с ожидаемым результатом")
       t.AddSubSuite(constants.PositiveSubSuite)
    t.WithNewStep("Создаем заказ", func(sCtx provider.StepCtx) {
              ctx := t.Context()
                ctx = metadata.AppendToOutgoingContext(ctx, constants.AccountIDHeader, data.accountID)
               resp, err := s.FlyBrokerClient.CreateOrder(ctx, data.request)
             s.AssertGrpcResponseSuccess(sCtx, resp, err)
              sCtx.Require().Equal(data.bookingStatus.String(), resp.GetBookingStatus().String(), "Проверяем, что статус заказа соответствует ожидаемому результату")
   })
}

• Должна начинаться с префикса TableTest
  
• Должна заканчиваться названием структуры с тестовыми данными
  
• Вторым аргументом должна принимать структуру с тестовыми данными

func TableTestCreateOrderPositiveTestData(t provider.T, data CreateOrderPositiveTestData)

• Должна начинаться с префикса Param 
  
• Должна заканчиваться названием структуры с тестовыми данными

s.ParamCreateOrderPositiveTestData = GetCreateOrderPositiveTestData

var GetCreateOrderPositiveTestData = []CreateOrderPositiveTestData{ //Данные теста }

• t.Parallel() // параллельный запуск тестов
  
• t.Skip() // Скип теста
  
• t.Assert() / t.Require() // Софт / хард - ассерты
  
• t.WithTestSetup() / t.WithTestTeardown() // сетап / завершение теста
  
• t.Title(), t.Description(), t.Epic() // более подробное описание тестов

• ломает прогон автотестов,
  
• заставляет команду перезапускать пайплайны,
  
• тратит часы на разбор «это баг или сбоит среда?»,
  
• замедляет релизы.

• тестировать позитивные сценарии
  
• проверять таймауты
  
• проверять ошибки провайдера

type AviaHandler struct{}
func NewAviaHandler() *AviaHandler {
     return &AviaHandler{}
}
func (h *AviaHandler) IssueTicket(req *restful.Request, resp *restful.Response) {
  if req.Request.Body == http.NoBody {
              _ = resp.WriteError(http.StatusBadRequest, errors.New("request body is required"))
                return
    }
    defer func() {
            _ = req.Request.Body.Close()
      }()
  bb, err := io.ReadAll(req.Request.Body)
   if err != nil {
           _ = resp.WriteError(http.StatusBadRequest, fmt.Errorf("read body err: %w", err))
          return
    }
    var requestBody model.IssueTicketRequest
  if err = json.Unmarshal(bb, &requestBody); err != nil {
           _ = resp.WriteError(http.StatusBadRequest, fmt.Errorf("parse body err: %w", err))
         return
    }
    var data model.IssueTicketResponse
        orderID := requestBody.OrderID
       switch orderID {
  case "success":
           data = model.IssueTicketResponse{
                 // заполнение успешного ответа
            }
 case "timeout":
           time.Sleep(5 * time.Second)
       case "error":
             _ = resp.WriteError(
                      http.StatusInternalServerError,
                   fmt.Errorf("provider error"),
             )
         return
    }
    if err := resp.WriteEntity(data); err != nil {
            _ = resp.WriteError(http.StatusInternalServerError, err)
  }
}

func InitAviaRoutes() *restful.WebService {
       webService := &restful.WebService{}
       aviaHandler := avia.NewAviaHandler()
 webService.
               Path("/avia").
            Produces(restful.MIME_JSON).
Route(webService.POST("/tickets/issue").To(aviaHandler.IssueTicket))
       return webService
}

• Тестировать happy path — проверять основной бизнес‑сценарий без влияния внешней нестабильности.
  
• Проверять ошибки от провайдера — 4xx/5xx, некорректные ответы.
  
• Эмулировать таймауты и проверять обработку деградаций.

• предсказуемые и воспроизводимые тесты;
  
• отсутствие флаки‑падений из‑за внешней среды;
  
• быстрое прохождение тестов в CI;
  
• возможность покрыть редкие и аварийные сценарии, которые сложно воспроизвести на реальном стенде.

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

db, err := gorm.Open(postgres.Open(dbDSN), &gorm.Config{})

func (r *Repository) AddOutbox(ctx context.Context, outbox model.Outbox) error {
      if err := r.db.WithContext(ctx).Create(&outbox).Error; err != nil {
               return fmt.Errorf("failed to add outbox record: %w", err)
 }
    return nil
}
func (r *Repository) DeleteOutbox(ctx context.Context, id string) error {
     if err := r.db.WithContext(ctx).Where("id = ?", id).Delete(&model.Outbox{}).Error; err != nil {
           return fmt.Errorf("failed to delete outbox record: %w", err)
      }
    return nil
}

type Consumer struct {
      reader *kafka.Reader
}
func NewConsumer(topic, consumerGroup string, brokers ...string) *Consumer {
        return &Consumer{
         reader: kafka.NewReader(kafka.ReaderConfig{
                       Brokers:        brokers,
                  Topic:          topic,
                    GroupID:        consumerGroup,
                    CommitInterval: 0,
                }),
       }
}
func (c *Consumer) Close() error {
     return c.reader.Close()
}
func (c *Consumer) ReadMessage(ctx context.Context) (kafka.Message, error) {
     msg, err := c.reader.ReadMessage(ctx)
     if err != nil {
           return kafka.Message{}, fmt.Errorf("failed to read message: %w", err)
     }
 if err := c.reader.CommitMessages(ctx, msg); err != nil {
         return kafka.Message{}, fmt.Errorf("failed to commit message: %w", err)
   }
    return msg, nil
}

• CommitInterval: 0 — отключение автокоммита, где сообщение считается успешно обработанным только после успешного коммита reader.CommitMessages(ctx, msg)
  
• reader.Close(): завершаем работу с топиком, чтобы избежать утечек

// Уже единичный тест, без параметризации
func (s *KafkaSuite) TestKafka(t provider.T) {
     t.Parallel()
      t.Title("Проверяем отправку сообщений в кафку из таблицы outbox")
 t.Description("Добавляем запись в таблицу outbox и проверяем, что запись по тикеру отправится в кафку")
   t.AddSubSuite(constants.PositiveSubSuite)
    outbox := createNewOutbox(model.StateProcessing, uuid.New().String(), faker.Sentence(), 10000)
       t.WithTestSetup(func(setupProvider provider.T) {
          err := s.Repo.AddOutbox(setupProvider.Context(), outbox)
          setupProvider.Require().NoError(err, "Проверяем, что запись в таблицу outbox успешно добавлена")
  })
   // Этот блок гарантированно выполнится, даже если дальнейшие шаги завершатся ошибкой
      defer func() {
            t.WithTestTeardown(func(teardownProvider provider.T) {
                    err := s.Repo.DeleteOutbox(t.Context(), outbox.ID)
                        teardownProvider.Require().NoError(err, "Проверяем, что запись из таблицы outbox успешно удалена")
                })
        }()
  t.WithNewStep("Проверяем отправку outbox в кафку", func(sCtx provider.StepCtx) {
          found, kafkaMessage := s.GetMessageFromOutboxTopic(t, outbox.ID, 15*time.Second)
          sCtx.Assert().True(found, fmt.Sprintf("Проверяем, что сообщение из топика outbox по id %v найдено", outbox.ID))
   })
}

rm -rf tests/allure-results &&
go clean -testcache && godotenv -f .env gotestsum --format testname – -p 1 ./…

• -rf tests/allure-results— перед запуском тестов удаляется папка allure-results, чтобы очистить старые результаты и сформировать отчет заново
  
• go clean -testcache — в Go кэшируются успешные тесты. И если код не менялся, то такие тесты заново не запускаются. Эта команда очищает кэш тестов, чтобы они гарантированно выполнялись 
  
• -format testname — простой формат по именам тестов. В консоли будут отображаться названия тестов
  
• - p 1 — ограничение по параллельности: запускаем 1 пакет за раз. Бывает полезна, чтобы, например, избежать race condition

allure generate tests/allure-results --clean -o
tests/allure-report
      allure open tests/allure-report

• PostgreSQL
  
• Kafka
  
• запущенное приложение fly-broker

• запущенный http-сервис, который эмулирует поведение внешнего сервиса avia-service

• контейнер, в котором выполняется запуск тестов

• независимым от тестовой инфраструктуры
  
• пригодным для локального запуска через docker-compose

• Создается единая сеть fly-broker-network, к которой будут подключаться контейнеры
  
• Поднимаются контейнеры fly-broker, mock-service, fly-broker-tests
  
• Выполняется проверка healthcheck: проверяем подключение к БД, доступность кафки, готовность приложения
  
• Сохранение allure-артефактов с тестами
  
• Джоба допускает падение

before_script:
    - docker network create fly-broker-network || true
  script:
    - docker-compose up -d --build
    - |
      echo "Waiting for fly-broker app (migrations + gRPC) to be ready..."
      for i in $(seq 1 60); do
        status=$(docker inspect fly-broker-app --format '{{.State.Health.Status}}' 2>/dev/null || echo "starting")
        [ "$status" = "healthy" ] && echo "Broker is ready." && break
        [ $i -eq 60 ] && echo "Broker did not become healthy in time." && exit 1
        sleep 2
      done
    - echo "Starting integration tests (fly-broker-tests)..."
    - cd fly-broker-tests && docker-compose build --no-cache tests && docker-compose run --rm tests
  artifacts:
    when: always
    paths:
      - fly-broker-tests/tests/allure-results
after_script:
  allow_failure: true

allure-report:
  stage: allure
  needs: [integration-tests]
  script:
    - mkdir -p fly-broker-tests/tests/allure-report
    - allure generate fly-broker-tests/tests/allure-results --clean -o fly-broker-tests/tests/allure-report
    - echo "Allure-report link - https://${CI_PROJECT_NAMESPACE}.${CI_PAGES_DOMAIN}/-/${CI_PROJECT_NAME}/-/jobs/${CI_JOB_ID}/artifacts/fly-broker-tests/tests/allure-report/index.html"
  artifacts:
    when: always
    paths:
      - fly-broker-tests/tests/allure-report
  allow_failure: false

• Go, я создал: пишем тесты на Allure-Go / Хабр
  
• Allure-провайдер от команды Ozon Tech