Скачать Автоматизация тестирования 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. Приветствие и инструкции:

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

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

Разбираемся, что такое API
Разбираемся, как работает HTTP API
Разбираемся, как работает gRPC API
4. Тестовый стенд:

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

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

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

Создаём модели
Создаём генератор тестовых данных
Создаём Builders
8. Создаём Runners и Suites:

Создаём Metadata
Меняем структуру тестов
Создаём корневой Runner
Создаём HTTP Runner и Suite
Создаём gRPC Runner и Suite
Обогащаем тесты Meta-информацией
9. Создаём API клиенты:

Создаём Config
Создаём HTTP Transport
Создаём HTTP API клиенты
Переводим HTTP-тесты на API клиенты
Создаём gRPC Transport
Создаём gRPC API клиенты
Переводим gRPC-тесты на API клиенты
10. Создаём Fixtures, Resources и Toolsets:

Создаём Resources
Создаём публичные HTTP Fixtures
Подготавливаем HTTP-авторизацию
Создаём приватные HTTP Fixtures
Создаём HTTP Data Fixtures
Собираем HTTP Toolset и переводим тесты
Создаём публичные gRPC Fixtures
Подготавливаем gRPC-авторизацию
Создаём приватные gRPC Fixtures
Создаём gRPC Data Fixtures
Собираем gRPC Toolset и переводим тесты
11. Создаём Assertions:

Создаём базовые Assertions
Создаём HTTP Assertions
Создаём gRPC Assertions
Подключаем Assertions к HTTP-инфраструктуре
Подключаем Assertions к gRPC-инфраструктуре
12. Подключаем Allure к проекту:

Знакомимся с Allure и устанавливаем Allure Report
Подключаем Allure к проекту
Настраиваем Allure Plugin проекта
13. Улучшаем тестовую инфраструктуру:

Подключаем логирование тестов
Запускаем тесты по тегам
Настраиваем параллельный запуск
14. Практикуемся в написании API-автотестов:

Практикуемся в написании HTTP API-автотестов. Часть 1
Практикуемся в написании HTTP API-автотестов. Часть 2
Практикуемся в написании HTTP API-автотестов. Часть 3
Практикуемся в написании gRPC API-автотестов. Часть 1
Практикуемся в написании gRPC API-автотестов. Часть 2
Практикуемся в написании gRPC API-автотестов. Часть 3
15. Запускаем автотесты в CI:

CI/CD и автотесты: Стратегия автоматизации тестирования
Разбираемся, что такое CI/CD
Знакомимся с GitHub Actions
Запускаем автотесты в GitHub Actions
16. Финальный проект:

Оформляем документацию проекта
Разбираем итоговую архитектуру
Подводим итоги курса
Автор Никита Филонов

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




СКАЧАТЬ СЛИВЫ КУРСОВ

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