Чему вы научитесь
- Анализировать и тестировать API, работающие по протоколам HTTP и gRPC.
- Понимать устройство API, клиент-серверное взаимодействие, ресурсы, эндпоинты, HTTP-запросы и ответы.
- Работать с gRPC-сервисами, Protocol Buffers, proto-контрактами и сгенерированным Go-кодом.
- Писать HTTP- и gRPC-автотесты на Go с использованием стандартного пакета testing.
- Применять Resty для отправки HTTP-запросов, работы с авторизацией, файлами, параметрами и телами запросов.
- Использовать Testify для проверок результатов выполнения автотестов.
- Генерировать реалистичные тестовые данные с помощью gofakeit.
- Проектировать переиспользуемые API-клиенты и отделять тестовые сценарии от транспортного слоя.
- Разрабатывать поддерживаемую инфраструктуру API-автотестов с использованием Axiom.
- Применять Builders, Fixtures, Resources и Toolsets для подготовки данных, состояния и зависимостей тестов.
- Разрабатывать базовые, протокольные и доменные Assertions для HTTP- и gRPC-проверок.
- Организовывать автотесты с помощью Runners, Suites, Cases, Metadata, Tags и Plugins.
- Проектировать независимые и детерминированные тестовые сценарии, безопасные для повторного и параллельного запуска.
- Проверять позитивные и негативные сценарии с упором на бизнес-логику и корректную диагностику ошибок.
- Настраивать повторный запуск нестабильных тестов и параллельное выполнение для ускорения тестового прогона.
- Работать с Allure: формировать подробные отчёты с шагами, логами, вложениями и информацией об окружении.
- Настраивать запуск API-автотестов в CI/CD и публиковать сформированные Allure-отчёты.
- Работать с выделенным тестовым сервером, запускать его локально и использовать в автоматизированных проверках.
- Применять переменные окружения и конфигурацию для управления параметрами тестового проекта.
- Использовать командную строку и основные инструменты для работы с HTTP- и gRPC-сервисами.
- Применять лучшие практики проектирования тестовой инфраструктуры и понимать, какую проблему решает каждый архитектурный слой.
О курсе
💻 Полноценная система 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-автотестов на Go:
- ✅ Разберём устройство 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 и публикацию отчётов.
- ✅ Оформим документацию и опубликуем финальный проект.
🤝 Что включает в себя поддержка преподавателя?
- ✅ Подробные ответы на вопросы – в комментариях с развернутыми объяснениями и примерами кода.
- ✅ Детальный фидбэк по заданиям – не просто разбор решения, а рекомендации по улучшению кода, применению лучших практик и реальных подходов из индустрии.
- ✅ Личная консультация – при возникновении сложных вопросов вы всегда можете обратиться к преподавателю и получить развернутый ответ.
- ✅ Проверка всех практических заданий – каждое задание проходит ручную проверку преподавателем, с разбором ошибок и советами по улучшению.
🔥 Как устроено обучение?
В процессе курса вы будете:
- ✅ изучать последовательные инженерные разборы;
- ✅ работать с примерами кода и схемами;
- ✅ выполнять тесты с автоматической проверкой;
- ✅ самостоятельно реализовывать практические задания;
- ✅ развивать один накопительный проект от первых запросов до финальной архитектуры;
- ✅ получать личную проверку решений и обратную связь преподавателя.
Каждый урок содержит концентрированный материал с объяснением определений, архитектурных решений, нюансов реализации и возможных ошибок.
⚠️ Важно! Модули в курсе будут открываться постепенно. Чтобы перейти к следующему модулю, необходимо набрать определенное количество баллов в текущем. Это вынужденная мера. Выполнять все задания не требуется, достаточно выполнить основную часть.
📚 Дополнительные бесплатные материалы
Перед прохождением курса, вы можете ознакомиться с моими статьями:
- 📄 Пишем gRPC автотесты на Go с Allure отчетом
- 📄 Визуализация покрытия автотестами для gRPC сервисов
- 📄 Лучшие практики автоматизации тестирования: 9 принципов стабильных автотестов
- 📄 Axiom — тестовый фреймворк для Go, которого нам всегда не хватало
- 📄 Как писать API-автотесты на Go: Axiom, Resty, Testify, Allure и запуск в CI/CD
- 📄 Фикстуры в Go: как перестать писать инфраструктуру в автотестах
- 📄 Почему в Go больно писать интеграционные тесты (и дело не в синтаксисе)
- 📄 Retry в Go автотестах: как перестать бояться flaky-тестов
- 📄 Плагины в Go-автотестах: как вынести инфраструктуру за пределы тестов
- 📄 И другие
🔗 Мои ресурсы:
- Telegram: https://t.me/qa_reality
- LinkedIn: https://www.linkedin.com/in/nikita-filonov-b945871a6/
- Medium: https://medium.com/@filonov.nikitkaa
- GitHub: https://github.com/Nikita-Filonov
- Сайт: https://nikitafilonov.dev
📌 Об авторских правах и официальной покупке курса
Курс распространяется только на платформе Stepik. Приобретая его здесь, вы получаете:
- Полный доступ ко всем материалам: тексты, схемы, задания, тесты, инфраструктура;
- Проверку заданий и развёрнутые рекомендации от меня лично;
- Обновления и новые модули, которые появляются по мере развития курса;
- Комментарии и поддержку — я регулярно отвечаю на вопросы, помогаю с кодом и разборами;
- Актуальные версии стенда, конфигов и приложений, которые синхронизированы с уроками.
🎓 Курс построен как живой инженерный продукт — с инфраструктурой, CI/CD, задачами и поддержкой. Всё это работает только в официальной версии.
💬 Если вы находите курс на сторонних сайтах — знайте, что в таких копиях:
- отсутствуют задания с проверкой;
- нет комментариев, обновлений и обратной связи;
- часто используются устаревшие материалы или неполные версии уроков.
Это уже не тот курс, который я задумывал.
Если вы хотите пройти курс «как он есть», с поддержкой, проверкой и развитием — проходите его здесь, на Stepik.
Для кого этот курс
Начальные требования
- Базовые знания Go. Понимание синтаксиса языка, умение работать с переменными, функциями, структурами, методами, указателями, интерфейсами, коллекциями и обработкой ошибок. Также важно понимать устройство пакетов и основы работы с Go Modules. Экспертный уровень не требуется, но язык в курсе не изучается с нуля.
- Базовое понимание программирования. Умение читать код, использовать условия и циклы, разбивать логику на функции, работать со структурами данных и подключать внешние библиотеки. Это поможет увереннее разбираться в архитектуре тестовой инфраструктуры.
- Общее понимание тестирования. Желательно знать, что такое тестовый сценарий, предусловия, ожидаемый результат, позитивные и негативные проверки. Опыт ручного тестирования API будет полезен, но глубокие знания HTTP и gRPC до начала курса не требуются — необходимые концепции разбираются в программе.
- Уверенная работа с компьютером и окружением разработки. Потребуется устанавливать программы и зависимости, работать с терминалом, запускать команды, пользоваться IDE — например, GoLand или VS Code, — редактировать конфигурационные файлы и работать с браузером.
- Готовность активно писать код. Курс построен вокруг одного накопительного проекта. Вам предстоит запускать тестовый сервер, писать HTTP- и gRPC-автотесты, изменять инфраструктуру, выполнять практические задания, анализировать ошибки и самостоятельно применять изученные подходы.
Наши преподаватели
Как проходит обучение
Каждый урок состоит из нескольких ключевых элементов:
- Теория и инженерные разборы. Подробные текстовые материалы с последовательным объяснением терминов, архитектурных решений и причин их появления. В уроках используются схемы, примеры кода, команды запуска, скриншоты и ссылки на дополнительную документацию.
- Практика внутри уроков. Все действия подробно разбираются непосредственно в тексте: от запуска тестового сервера и первых HTTP- и gRPC-запросов до проектирования клиентов, фикстур, проверок, отчётности, параллельного запуска и CI/CD. Вы сможете проходить материал в собственном темпе и возвращаться к любому этапу реализации.
- Тесты с автоматической проверкой. Квизы помогают закрепить определения, принципы работы инструментов и архитектурные решения. Они проверяют не только запоминание терминов, но и понимание того, зачем используется каждый подход.
- Практические задания. После изучения материала вам предстоит самостоятельно дополнять проект, писать автотесты и применять изученные компоненты. Задания продолжают развитие общей инфраструктуры и постепенно усложняются вместе с курсом.
- Личная проверка решений. Все практические задания проверяются преподавателем. Вы получите обратную связь по выполнению условий, найденным ошибкам, структуре решения и применению изученных подходов.
- Поддержка преподавателя. При возникновении вопросов по материалам, заданиям, тестовому серверу или техническим проблемам можно обратиться за помощью в комментариях и обсуждениях курса.
Курс построен вокруг одного накопительного проекта. Вы будете последовательно развивать его от первых API-запросов до полноценной инфраструктуры HTTP- и gRPC-автотестов с тестовыми данными, клиентами, фикстурами, доменными проверками, Allure-отчётностью, параллельным запуском и CI/CD.
Программа курса
Сертификат
Отзывы прошедших курс
Что вы получаете
- Фундаментальное понимание автоматизации тестирования API на Go. Вы разберётесь не только в отправке HTTP-запросов и вызове gRPC-методов, но и в проектировании всей тестовой инфраструктуры: от транспорта и API-клиентов до тестовых данных, проверок, отчётности и CI/CD.
- Системные знания, которые не зависят от одной библиотеки. Курс построен вокруг инженерных принципов: разделения ответственности, управления зависимостями и состоянием, переиспользования компонентов, диагностики ошибок и безопасного параллельного запуска.
- Практический опыт работы с HTTP и gRPC. Вы будете тестировать API через два интерфейса, работать с позитивными и негативными сценариями, связанными данными, бизнес-правилами, ошибками и подготовкой состояния.
- Полноценный проект. По итогам курса у вас останется оформленный проект API-автотестов на Go с транспортным слоем, переиспользуемыми клиентами, Builders, Resources, Fixtures, Toolset, доменными Assertions, Allure-отчётностью и автоматизированным запуском.
- Опыт построения архитектуры с нуля. Вы последовательно пройдёте путь от простых тестов до масштабируемой инфраструктуры и поймёте, какую проблему решает каждый её слой.
- Материал по Axiom от автора фреймворка. Вы изучите причины появления его архитектурных сущностей, принятые решения, ограничения и практику применения на больших наборах тестов.
- Отработку знаний на практике. Практические задания продолжают развитие проекта и требуют самостоятельно применять изученные подходы, писать тесты, изменять инфраструктуру и анализировать результаты запусков.
- Личную проверку и обратную связь. Все практические задания проверяются преподавателем. Вы получите разбор ошибок, рекомендации по улучшению решения и доступ к эталонным вариантам реализации.
- Проект для портфолио и дальнейшего развития. Финальный репозиторий можно использовать как демонстрацию практических навыков, основу для собственных проектов или отправную точку при создании тестовой инфраструктуры в рабочей команде.