Автоматизация тестирования API с Go [Stepik] [Никита Филонов]

Складчина: Автоматизация тестирования API с Go [Stepik] [Никита Филонов]

Вы освоите HTTP, gRPC, Resty, Protobuf, Axiom, Allure, Testify, gofakeit и CI/CD. Научитесь строить полноценную инфраструктуру API-автотестов на Go, проектировать поддерживаемую архитектуру, настраивать параллельный запуск и отчётность, применять лучшие практики и работать с реальными сценариями. В финале соберёте готовый проект — от первых API-запросов до полноценного тестового фреймворка.

Полноценная система API-автотестов на Go:

Написать несколько HTTP- или gRPC-тестов на Go несложно. Для этого достаточно Resty, Protobuf, Testify и стандартного пакета testing.
Проблемы начинаются тогда, когда тестов становится не десять, а несколько сотен.
В этот момент простые примеры перестают масштабироваться. Тесты начинают дублировать друг друга, подготовка данных занимает больше места, чем сам сценарий, API-клиенты смешиваются с бизнес-логикой, параллельный запуск ломает состояние, а диагностика падений превращается в отдельное расследование.
Ни Resty, ни Testify, ни Protobuf сами по себе не решают эти задачи. Это инструменты, а не архитектура.

В этом курсе вы не просто напишете набор API-тестов. Вы последовательно построите полноценную инфраструктуру HTTP- и gRPC-автотестов на Go и разберётесь, как сделать её:

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

Спойлер: Подробнее о курсе:

Главная цель курса:

Курс формирует комплексную и фундаментальную базу для проектирования API-автотестов на Go.
Мы начнём с устройства API, клиент-серверного взаимодействия, HTTP и gRPC. Затем напишем первые тесты с использованием стандартного пакета testing, Resty, Protobuf и Testify. После этого будем постепенно развивать проект: отделять транспортный слой, создавать API-клиенты, управлять тестовыми данными, проектировать фикстуры и проверки, подключать отчётность, логирование, параллельный запуск и CI/CD.
Главный результат — понимание всей системы автоматизации: от отправки запроса до архитектуры проекта, жизненного цикла тестовых данных, диагностики ошибок и организации больших тестовых наборов.

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

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

Почему автоматизация тестирования на Go требует отдельного подхода:

В Go нет единственного общепринятого стека, который полностью решает задачи большого проекта автотестов.
Стандартный пакет testing предоставляет надёжную и предсказуемую основу, но оставляет разработчику большую часть инфраструктурных решений.
Testify дополняет стандартную библиотеку удобными проверками и тестовыми наборами, однако самостоятельно не решает вопросы архитектуры проекта, управления зависимостями, метаданных, плагинов, отчётности и организации сложного параллельного запуска.

Ginkgo предлагает полноценный BDD-подход и собственный DSL, добавляя дополнительный уровень абстракции, который подходит одним командам и не соответствует требованиям других.
Поэтому тестовая инфраструктура в Go редко возникает из простого объединения нескольких библиотек. Её приходится осознанно проектировать: определять границы компонентов, жизненный цикл зависимостей, правила подготовки данных, структуру тестов и механизм их выполнения.

Многие команды годами выращивают такую инфраструктуру самостоятельно или переносят решения из Java, Python и других языков. Часть этих подходов полезна, но некоторые из них плохо сочетаются с простотой и явностью, которые приняты в экосистеме Go.
В курсе мы разберём эти особенности и построим архитектуру, которая остаётся понятной, расширяемой и естественной для Go-проекта.

Три с половиной года практики, собранные в одном курсе:

В основе курса лежат три с половиной года интенсивной работы с API-, интеграционными и изоляционными автотестами на Go.
За это время я создавал и поддерживал тестовую инфраструктуру, наблюдал за её развитием вместе с продуктами, внедрял решения в разных командах, сталкивался с ограничениями существующих инструментов и неоднократно пересматривал неудачные архитектурные подходы.

На практике мне приходилось решать ситуации, когда:

• тесты невозможно безопасно запускать параллельно
• подготовка данных становится сложнее самого сценария
• фикстуры превращаются в набор несвязанных функций
• инфраструктурный код копируется между десятками тестов
• API-клиенты смешивают транспорт, модели и бизнес-логику
• логирование и отчётность подключаются вручную
• повторные запуски скрывают реальные причины нестабильности
• тесты работают локально, но регулярно падают в CI
• архитектура становится настолько сложной, что команда боится её изменять

Эти проблемы не были придуманы специально для учебных примеров. Они возникали при развитии настоящих тестовых проектов. Работа над их решением в конечном итоге привела к созданию Axiom.

Материал про Axiom из первых рук:

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

В курсе разбирается опыт, который невозможно получить из одного README или набора примеров:

• какие подходы рассматривались на ранних этапах
• от каких решений пришлось отказаться
• какие проблемы проявились только при росте количества тестов
• что пришлось переписывать после внедрения
• как различные механизмы работают при параллельном запуске
• как фреймворк ведёт себя на больших тестовых наборах
• какие компромиссы приходится учитывать при проектировании инфраструктуры

Resty, Testify, Protobuf и Allure можно изучать отдельно по документации. В этом курсе они объединяются в одну систему вместе с архитектурой, тестовыми данными, клиентами, фикстурами, проверками, отчётностью и CI/CD.
По сочетанию авторского фреймворка, материала от его создателя и последовательного построения полноценной инфраструктуры курс не имеет прямых аналогов.

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

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

Последовательный путь к архитектуре:

В первом модуле вы не получите огромный готовый фреймворк, структуру которого останется только скопировать.
Мы начнём с простых API-автотестов на Go. По мере развития проекта будут появляться реальные проблемы: дублирование кода, сложная подготовка данных, разрозненные клиенты, неудобные проверки, смешивание транспортного и сценарного уровней.
Каждый следующий архитектурный слой будет добавляться как решение уже понятной проблемы.

Шаг за шагом в проекте появятся:

• модели и генерация тестовых данных
• Builders
• HTTP- и gRPC-транспорты
• переиспользуемые API-клиенты
• Resources и Fixtures
• Toolset
• базовые, протокольные и доменные Assertions
• Runner, Suites и Cases
• метаданные и шаги
• Allure Report
• техническое логирование
• плагины и теги
• повторные запуски
• параллельное выполнение
• автоматизированный запуск в CI/CD

Такой подход помогает запомнить не только итоговую структуру каталогов и файлов. Вы увидите причинно-следственную связь между возникающей проблемой и архитектурным решением, которое её устраняет.
Именно это позволяет в дальнейшем самостоятельно проектировать тестовую инфраструктуру, а не зависеть от готовых шаблонов.

Практика на реальных бизнес-сценариях:

Курс строится вокруг выделенного тестового сервера с HTTP- и gRPC-интерфейсами.
Вы будете работать со связанными и вложенными данными, создавать и изменять ресурсы, передавать идентификаторы между запросами, проверять бизнес-правила, обрабатывать ошибки и восстанавливать необходимое состояние перед выполнением тестов.

К финалу вы реализуете полноценное покрытие HTTP- и gRPC API: позитивные и негативные сценарии, работу со связанными данными, проверку бизнес-правил, обработку ошибок и управление состоянием тестов.
Каждый сценарий используется не только для расширения покрытия, но и для развития инфраструктуры, проверки архитектурных решений и отработки подходов, применяемых в реальных проектах.

Что входит в курс:

• Разберём устройство API, клиент-серверное взаимодействие, HTTP и gRPC
• Подготовим рабочее окружение и запустим выделенный тестовый сервер
• Напишем первые HTTP- и gRPC-автотесты без сложной инфраструктуры
• Изучим возможности стандартного пакета testing, Resty, Testify, Protobuf и gofakeit
• Познакомимся с Axiom и разберём Runner, Suite, Case, Meta, Steps, Fixtures, Resources, Toolset и Plugins
• Создадим модели, Builders и генерацию тестовых данных
• Спроектируем отдельные транспорты и API-клиенты для HTTP и gRPC
• Организуем подготовку состояния через Resources и Fixtures
• Соберём зависимости тестов в единый Toolset
• Разработаем собственные базовые, протокольные и доменные Assertions
• Подключим Allure Report, техническое логирование и информацию об окружении
• Настроим запуск тестов по тегам, повторные и параллельные прогоны
• Расширим покрытие позитивными и негативными бизнес-сценариями
• Автоматизируем запуск тестов в CI/CD и публикацию отчётов
• Оформим документацию и опубликуем финальный проект

Как устроено обучение:

В процессе курса вы будете:

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

Каждый урок содержит концентрированный материал с объяснением определений, архитектурных решений, нюансов реализации и возможных ошибок.

Для кого этот курс:

• Для QA Automation-инженеров, которые работают с Python, Java, TypeScript или другими языками и хотят перейти на Go
• Для ручных QA-инженеров, которые уже работают с API, изучили основы Go и хотят перейти к автоматизации тестирования HTTP- и gRPC-сервисов
• Для инженеров, которые умеют писать отдельные тесты с testing, Resty и Testify, но хотят научиться строить масштабируемую и поддерживаемую тестовую инфраструктуру
• Для QA Automation-инженеров, которые хотят глубже разобраться в архитектуре автотестов, подготовке тестовых данных, API-клиентах, фикстурах, проверках, логировании и отчётности
• Для SDET, senior automation-инженеров и QA Leads, которые проектируют тестовые фреймворки, развивают существующую инфраструктуру и принимают архитектурные решения
• Для Go-разработчиков, которым необходимо писать API-, интеграционные и изоляционные тесты для своих сервисов
• Для инженеров, работающих с Go-сервисами и желающих одинаково уверенно тестировать HTTP- и gRPC-интерфейсы
• Для специалистов, которым важно научиться проектировать независимые тесты, безопасно запускать их параллельно, диагностировать падения и интегрировать автотесты в CI/CD
• Для тех, кто уже пробовал строить автотесты на Go, но столкнулся с дублированием кода, сложной подготовкой данных, разрозненными клиентами и отсутствием цельной архитектуры
• Для инженеров, которые хотят не просто скопировать готовый шаблон, а понять, какую проблему решает каждый слой тестовой инфраструктуры и как развивать проект вместе с ростом количества тестов

Начальные требования:

• Базовые знания Go.
  Понимание синтаксиса языка, умение работать с переменными, функциями, структурами, методами, указателями, интерфейсами, коллекциями и обработкой ошибок. Также важно понимать устройство пакетов и основы работы с Go Modules. Экспертный уровень не требуется, но язык в курсе не изучается с нуля
• Базовое понимание программирования.
  Умение читать код, использовать условия и циклы, разбивать логику на функции, работать со структурами данных и подключать внешние библиотеки. Это поможет увереннее разбираться в архитектуре тестовой инфраструктуры
• Общее понимание тестирования.
  Желательно знать, что такое тестовый сценарий, предусловия, ожидаемый результат, позитивные и негативные проверки. Опыт ручного тестирования API будет полезен, но глубокие знания HTTP и gRPC до начала курса не требуются — необходимые концепции разбираются в программе
• Уверенная работа с компьютером и окружением разработки.
  Потребуется устанавливать программы и зависимости, работать с терминалом, запускать команды, пользоваться IDE — например, GoLand или VS Code, — редактировать конфигурационные файлы и работать с браузером
• Готовность активно писать код.
  Курс построен вокруг одного накопительного проекта. Вам предстоит запускать тестовый сервер, писать HTTP- и gRPC-автотесты, изменять инфраструктуру, выполнять практические задания, анализировать ошибки и самостоятельно применять изученные подходы

Программа:

1. Приветствие и инструкции:

1. Правила работы с курсом и коммуникации
2. Знакомимся
3. Советы по изучению материала
4. Инструкции по отправке заданий на проверку
5. Поддержка от преподавателя и вопросы

2. Создание проекта:

1. Создаём Go module
2. Публикуем проект на GitHub
3. Выбираем IDE для курса
4. Устанавливаем Go

3. Разбираемся в API:

1. Разбираемся, что такое API
2. Разбираемся, как работает HTTP API
3. Разбираемся, как работает gRPC API

4. Тестовый стенд:

1. Подготавливаем тестовый стенд
2. Запускаем тестовый стенд
3. Проверяем работоспособность тестового стенда
4. Разбираем архитектуру тестового стенда
5. Разбираем HTTP-контракт
6. Разбираем gRPC-контракт
7. Разбираем авторизацию тестового стенда

5. Первые API-тесты:

1. Введение в API-автотесты на Go
2. Подключаем библиотеки для первых API-тестов
3. Пишем первые HTTP API-тесты
4. Пишем первые gRPC API-тесты
5. Разбираем Go-тесты. Часть 1: фикстуры
6. Разбираем Go-тесты. Часть 2: жизненный цикл
7. Разбираем Go-тесты. Часть 3: перезапуски
8. Разбираем Go-тесты. Часть 4: параллельность
9. Разбираем Go-тесты. Часть 5: метаданные
10. Разбираем Go-тесты. Часть 6: плагины

6. Знакомимся с Axiom:

1. Что такое Axiom и зачем он нужен
2. Пишем первый тест с Axiom
3. Разбираем Runner, Case и Config
4. Группируем тесты в Suite
5. Добавляем Meta к тестам
6. Управляем зависимостями с помощью Fixtures, Resources
7. Собираем инструменты в Toolset
8. Управляем Retry, Parallel и Skip
9. Управляем жизненным циклом с помощью Hooks
10. Управляем контекстом выполнения тестов
11. Структурируем тесты с помощью Step, Setup и Teardown
12. Расширяем Axiom с помощью Plugins
13. Подводим итоги: какие проблемы решает Axiom
14. Параметризуем тесты с помощью Params

7. Создаём модели и тестовые данные:

1. Создаём модели
2. Создаём генератор тестовых данных
3. Создаём Builders

8. Создаём Runners и Suites:

1. Создаём Metadata
2. Меняем структуру тестов
3. Создаём корневой Runner
4. Создаём HTTP Runner и Suite
5. Создаём gRPC Runner и Suite
6. Обогащаем тесты Meta-информацией

9. Создаём API клиенты:

1. Создаём Config
2. Создаём HTTP Transport
3. Создаём HTTP API клиенты
4. Переводим HTTP-тесты на API клиенты
5. Создаём gRPC Transport
6. Создаём gRPC API клиенты
7. Переводим gRPC-тесты на API клиенты

10. Создаём Fixtures, Resources и Toolsets:

1. Создаём Resources
2. Создаём публичные HTTP Fixtures
3. Подготавливаем HTTP-авторизацию
4. Создаём приватные HTTP Fixtures
5. Создаём HTTP Data Fixtures
6. Собираем HTTP Toolset и переводим тесты
7. Создаём публичные gRPC Fixtures
8. Подготавливаем gRPC-авторизацию
9. Создаём приватные gRPC Fixtures
10. Создаём gRPC Data Fixtures
11. Собираем gRPC Toolset и переводим тесты

11. Создаём Assertions:

1. Создаём базовые Assertions
2. Создаём HTTP Assertions
3. Создаём gRPC Assertions
4. Подключаем Assertions к HTTP-инфраструктуре
5. Подключаем Assertions к gRPC-инфраструктуре

12. Подключаем Allure к проекту:

1. Знакомимся с Allure и устанавливаем Allure Report
2. Подключаем Allure к проекту
3. Настраиваем Allure Plugin проекта

13. Улучшаем тестовую инфраструктуру:

1. Подключаем логирование тестов
2. Запускаем тесты по тегам
3. Настраиваем параллельный запуск

14. Практикуемся в написании API-автотестов:

1. Практикуемся в написании HTTP API-автотестов. Часть 1
2. Практикуемся в написании HTTP API-автотестов. Часть 2
3. Практикуемся в написании HTTP API-автотестов. Часть 3
4. Практикуемся в написании gRPC API-автотестов. Часть 1
5. Практикуемся в написании gRPC API-автотестов. Часть 2
6. Практикуемся в написании gRPC API-автотестов. Часть 3

15. Запускаем автотесты в CI:

1. CI/CD и автотесты: Стратегия автоматизации тестирования
2. Разбираемся, что такое CI/CD
3. Знакомимся с GitHub Actions
4. Запускаем автотесты в GitHub Actions

16. Финальный проект:

1. Оформляем документацию проекта
2. Разбираем итоговую архитектуру
3. Подводим итоги курса

Автор Никита Филонов

• Автор месяца Stepik 2025
• Победитель Stepik Awards 2025 в номинациях «Программирование и разработка», «Лучшее сопровождение курса»
• 10 лет в области QA Automation, три года в должности QA Lead
• Опыт автоматизации тестирования на Python, JavaScript/TypeScript, C#, Golang, Swift в боевых проектах
• Автор тестового фреймворка Axiom

Цена 5980 руб.
Скрытая ссылка