← Все статьи

Мы автоматизируем не ту часть тестирования?

Почему мы используем AI-агентов для написания автотестов, если они могут выполнять проверки сами? Размышления о тестировании без отдельного слоя тестового кода.

Последнее время я всё чаще вижу в LinkedIn публикации о новых инструментах и фреймворках, которые используют AI для автоматизации тестирования.

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

Это действительно впечатляет. Мне нравится наблюдать, как активно инженерное сообщество экспериментирует с AI, создаёт новые инструменты и делится результатами своей работы.

Но каждый раз, когда я вижу очередное подобное решение, у меня возникает один и тот же вопрос: а правильно ли мы используем возможности AI-агентов?

Автоматизация автоматизации

AI-агенты уже сами по себе являются инструментом автоматизации. Они способны взаимодействовать с программами, вызывать различные утилиты, анализировать результаты и принимать решения о дальнейших действиях.

Но в тестировании мы часто используем их для того, чтобы они писали программный код, который затем будет выполнять автоматизированные проверки.

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

Мем с кибернетическим Xzibit: слышал, ты любишь автоматизацию тестирования, поэтому мы автоматизировали написание твоих автотестов.

И я начал задумываться: а действительно ли нам необходим этот промежуточный слой программного кода?

Возможно, с появлением AI-агентов у нас возникла альтернатива привычному подходу к автоматизированному тестированию, которую мы пока недостаточно исследовали.

Нужен ли нам промежуточный слой?

Давайте рассмотрим простой пример.

Предположим, нам нужно проверить ответ веб-сервиса на определённый HTTP-запрос.

При ручном тестировании мы можем воспользоваться curl, отправить запрос, посмотреть на полученный ответ и сравнить его с ожидаемым результатом.

Если мы захотим автоматизировать эту проверку традиционным способом, то, скорее всего, напишем небольшой тест на Python, Java или другом языке программирования. Он отправит запрос, получит ответ и выполнит необходимые проверки.

Разумеется, в реальных проектах мы обычно используем библиотеки для работы с HTTP, а не вызываем curl из программного кода. Но для нашего примера это не принципиально.

Суть в том, что программный код позволяет нам автоматически воспроизводить определённую последовательность действий и проверять её результат.

А теперь представим, что вместо написания такого теста мы передаём AI-агенту инструкцию: отправить запрос к определённому адресу, проверить код ответа и убедиться, что полученные данные соответствуют ожидаемым.

Агент может самостоятельно вызвать тот же curl, получить результат и выполнить проверку.

Зачем в таком случае сначала создавать Python-код, если агент уже способен выполнить необходимые действия?

Конечно, это не означает полного отказа от программирования. Сам агент, его инструменты и инфраструктура взаимодействия с тестируемой системой продолжают использовать программный код.

Но, возможно, нам больше не потребуется писать отдельную программную реализацию для каждого тестового сценария.

Вместо неё мы сможем использовать инструкции, понятные одновременно человеку и AI-агенту.

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

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

А что насчёт self-healing?

Традиционные автоматизированные тесты обычно выполняют заранее определённую последовательность действий. Если результат не соответствует заложенным условиям, тест завершается ошибкой.

И это часто именно то поведение, которое нам необходимо.

Но иногда тесты ломаются не из-за дефекта в продукте, а из-за незначительных изменений в окружении, формате вывода или способе взаимодействия с системой.

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

AI-агент потенциально способен разобраться в такой ситуации непосредственно во время выполнения теста.

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

Мне кажется, что именно здесь может проявиться более естественный подход к self-healing automation.

Хотя есть важное ограничение.

Агент не должен самостоятельно решать, какие требования можно игнорировать.

Если точное содержимое ответа, включая пробелы, кавычки или форматирование, является частью проверяемого контракта, любое отклонение должно считаться потенциальным дефектом.

Адаптироваться можно к способу выполнения проверки, но не к самим критериям её успешности. При этом важно фиксировать, какие действия агент изменил и почему, чтобы адаптация не скрыла дефект.

Иначе мы рискуем получить тесты, которые прекрасно приспосабливаются к изменениям, но перестают обнаруживать настоящие ошибки.

Почему это может быть полезно именно сейчас?

Традиционная автоматизация особенно хорошо проявляет себя в регрессионном тестировании.

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

Однако в проектах с короткими циклами поставки изменения происходят часто, новые возможности появляются быстро, и тестовая автоматизация должна успевать за этим темпом.

При этом создание качественного автотеста требует времени.

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

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

И здесь возникает интересная возможность.

Если человек уже знает, какие действия необходимо выполнить и какой результат должен быть получен, почему бы не передать выполнение этой проверки непосредственно AI-агенту?

Возможно, мы сможем сократить время между появлением тестового сценария и его первым выполнением AI-агентом.

Это не означает, что традиционные автотесты становятся хуже или теряют актуальность. Но в условиях частых изменений стоимость их разработки и сопровождения может оказаться важнее скорости отдельного запуска.

А какова цена такого подхода?

Разумеется, у агентного исполнения есть существенные недостатки.

Первый — стоимость и время выполнения.

Хорошо написанный программный тест обычно выполняется быстро и с небольшими вычислительными затратами. AI-агенту же необходимо интерпретировать инструкции, обращаться к модели, взаимодействовать с инструментами и анализировать результаты.

Поэтому вполне вероятно, что агентная проверка окажется медленнее и дороже традиционной.

Второй недостаток — недетерминированность.

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

Я предполагаю, что достаточно хорошо сформулированные инструкции и правильно подобранные модели позволят снизить вероятность таких ошибок. Но пока это лишь гипотеза, которую необходимо проверить экспериментально.

При этом необязательно использовать самую мощную и дорогую модель для каждой проверки.

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

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

Пока у меня нет ответа на этот вопрос.

От тестового сценария к исполняемой инструкции

Есть и ещё одно потенциальное преимущество, о котором я раньше почти не задумывался.

Обычно мы разделяем описание тестового сценария и его программную реализацию.

Первое предназначено для человека. Второе — для системы автоматизации. Оба эти представления необходимо поддерживать, а при изменениях они могут расходиться друг с другом.

Но что, если одно описание сможет использоваться и человеком, и агентом?

Например, инженер выполняет новую проверку вручную, взаимодействуя с системой вместе с AI-агентом. В процессе они формируют последовательность действий, уточняют ожидаемые результаты и сохраняют полученную инструкцию.

Впоследствии этот сценарий может выполнить другой инженер или сам агент.

Конечно, подобные инструкции тоже потребуется поддерживать, проверять и уточнять. Но, возможно, нам удастся избавиться от необходимости отдельно реализовывать одну и ту же проверку в программном коде.

И это уже не только вопрос скорости написания тестов. Это возможность сблизить тест-дизайн, ручное тестирование и автоматизированное исполнение.

Стоит попробовать

Я не утверждаю, что AI-агенты способны заменить традиционную автоматизацию тестирования. Но кажется, что мы подошли к интересному моменту, когда стоит пересмотреть некоторые привычные инженерные решения.

Написание программного кода до недавнего времени было одним из основных способов создавать гибкие и повторно выполняемые автоматизированные проверки. Теперь у нас появился ещё один возможный исполнитель — AI-агент, способный понимать инструкции и самостоятельно взаимодействовать с инструментами.

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

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

Но сейчас мне определённо кажется, что игра стоит свеч.