Тесты от AI: почему сгенерированные тесты проверяют код, а не требования
Текст написан с позиции июля 2026 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Из всего, что AI научился делать за последние пару лет, генерация тестов выглядит самым безобидным и самым очевидно полезным. Тесты никто не любит писать, они скучные, их вечно не хватает, а покрытие на дашборде годами висит где-то в районе сорока процентов. И вот появляется инструмент, который за минуту выдаёт сотню аккуратных кейсов, всё зелёное, coverage подскакивает до девяноста. Кажется, что одна из самых застарелых проблем индустрии наконец решена почти бесплатно.
Самая вредная реакция на это — решить, что тестовый долг закрыт. Потому что у сгенерированных тестов есть системный дефект, который не виден ни в отчёте о покрытии, ни в зелёном CI. Модель, которая пишет тест, почти всегда смотрит в реализацию. Она читает функцию, понимает, что функция делает, и фиксирует это поведение в assertions. В результате тест отвечает на вопрос «делает ли код то, что он делает», а не на вопрос «делает ли код то, что должен».
Это не мелкая придирка, а разница между тестом и его имитацией. Тест, написанный по коду, закрепляет текущее поведение вместе со всеми его ошибками. Если в функции off-by-one, тест аккуратно проверит, что off-by-one на месте. Ниже — о том, почему так происходит, как это распознать и как выстроить работу, при которой AI действительно экономит время на тестах, а не создаёт иллюзию надёжности.
Модель пишет тест из того единственного источника правды, который ей дали
Механика проста и не зависит от того, насколько умная модель. Когда вы просите «напиши тесты для этого модуля», единственный доступный контекст — сам модуль. Требований в нём нет. Нет тикета, где написано, что скидка не должна суммироваться с промокодом. Нет разговора с аналитиком, где выяснилось, что пустой список — это ошибка, а не валидный результат. Есть код, и модель делает единственное разумное в этой ситуации: выводит ожидаемое поведение из фактического.
Почему это так коварно? Потому что результат выглядит профессионально. Названия кейсов осмысленные, структура describe / it аккуратная, граничные значения вроде бы перебраны. Модель честно прошла по веткам и для каждой написала проверку. Но ожидаемые значения в этих проверках она не знала заранее — она их вычислила, мысленно исполнив код. А значит, тест по определению совпадает с реализацией. Он не может упасть на текущем коде, потому что из текущего кода и получен.
У тестировщиков для этого давно есть термин — test oracle, источник знания о том, каким должен быть правильный ответ. В классическом процессе оракул — это спецификация, требования, здравый смысл человека, который понимает домен. В сгенерированном тесте оракулом становится сама проверяемая функция. Получается замкнутый круг: код проверяется самим собой, и любая ошибка в нём автоматически становится «ожидаемым поведением».
Зелёный CI, который ничего не доказывает
Тест ценен ровно в той мере, в какой он способен упасть. Тест, который не может упасть ни при каком разумном изменении, — это не проверка, а декорация. И сгенерированные по коду тесты очень часто оказываются именно такими: они проходят сегодня, пройдут завтра и будут проходить, пока кто-нибудь не поменяет сигнатуру. На регрессии в логике они реагируют плохо, потому что фиксируют поверхность, а не смысл.
Самое неприятное в этой ситуации — метрики начинают врать в нужную сторону. Coverage вырос, количество тестов выросло, CI зелёный, и у команды появляется уверенность, которая ничем не подкреплена. Покрытие строк говорит только о том, что строка была исполнена во время теста. Оно ничего не говорит о том, была ли проверена её корректность. Можно иметь стопроцентное покрытие и ни одного assertion, который поймал бы реальную ошибку.
Если сформулировать совсем прямо: зелёный CI на сгенерированных тестах доказывает, что код не изменился, а не что он правильный. Для регрессионной защиты уже работающего и проверенного кода это иногда полезно. Для нового кода, который ещё никто не сверял с требованиями, — почти бесполезно, а иногда и вредно, потому что закрепляет баг и делает его исправление дороже: теперь чинить нужно и код, и тест, который «защищал» ошибку.
Как выглядят тесты, которые проверяют сами себя
Через несколько месяцев работы с AI-тестами у меня сложился довольно устойчивый каталог симптомов. Первый и самый частый — тавтология. Ожидаемое значение в тесте вычисляется тем же способом, что и в коде, иногда буквально тем же вызовом: expect(calcTotal(items)).toEqual(items.reduce(...)), где внутри reduce повторена формула из calcTotal. Такой тест проверяет, что формула равна самой себе. Ошибиться в нём невозможно, и найти ошибку тоже.
Второй симптом — тотальный mocking. Модель видит зависимости и аккуратно подменяет каждую: репозиторий, HTTP-клиент, логгер, часы, конфиг. В итоге тест проверяет, что функция вызвала мок с теми аргументами, с которыми она его вызывает. Это проверка реализации в самом буквальном смысле: любой рефакторинг, который не меняет поведение, ломает такой тест, а любая ошибка в том, как данные проходят через реальные зависимости, остаётся невидимой. Тест становится не страховкой, а тормозом изменений.
Третий — snapshot spam. Если в проекте есть snapshot-тесты, модель охотно генерирует их на всё подряд: на компоненты, на сериализованные объекты, на ответы API. Снапшот по своей природе фиксирует текущее состояние без всякого суждения о том, правильное ли оно. Когда снапшотов сотни, никто не читает их диффы, и обновление командой -u становится рефлексом. Снапшот, который обновляют не глядя, проверяет только то, что вы не забыли его обновить.
Четвёртый, более тонкий, — тесты на детали вместо контракта. Проверка того, что внутренний метод вызван дважды, что приватное поле имеет определённое значение, что массив отсортирован именно этим алгоритмом. Всё это наблюдаемо в коде, поэтому модель это и проверяет. Но пользователю функции всё равно, сколько раз вызван внутренний метод, — ему важно, что на выходе.
Почему модель не спрашивает, чего вы хотели
Можно было бы списать всё на слабость инструмента и ждать, пока модели поумнеют. Но проблема не в интеллекте. Хорошая модель вполне способна заметить, что функция подозрительно обрабатывает пустой ввод, и иногда даже об этом скажет. Проблема в постановке задачи. «Напиши тесты для этого кода» — это просьба описать код тестами, и модель её добросовестно выполняет. Она не знает, что вы считаете правильным, если вы этого не сказали.
Есть и второй фактор, о котором говорят реже. Сгенерированный тест, который падает, выглядит как неудача генерации. Если модель напишет тест по требованию, а код ему не соответствует, пользователь увидит красный CI и, скорее всего, решит, что тест кривой. Агентные инструменты, которые сами запускают тесты и итерируют до зелёного, усиливают этот эффект: при расхождении проще поправить assertion, чем разбираться, кто прав. Без явного указания «код может быть неверным, тест важнее» система оптимизируется на зелёный результат, а не на правду.
Поэтому не стоит думать, что следующее поколение моделей решит вопрос само. Оно будет писать более аккуратные тесты по коду, но источник правды от этого не появится. Требования живут в головах, тикетах и договорённостях, и пока они не попали в контекст, модели неоткуда их взять.
Требования сначала, код потом — старая идея, которая снова окупается
Лекарство не новое, и в этом есть определённая ирония. Test-first, TDD, acceptance criteria, BDD — всё это придумано задолго до AI и долго воспринималось как дисциплина для энтузиастов. С появлением генерации у этих практик появился очень прагматичный смысл: они разрывают замкнутый круг, потому что тест появляется раньше кода и, следовательно, не может быть из него выведен.
На практике это не обязательно классический TDD с красным-зелёным-рефакторингом на каждую строчку. Мне хватает куда более лёгкой версии. Перед реализацией я записываю список кейсов обычным текстом: что принимает функция, что возвращает, какие граничные случаи важны, что считается ошибкой. Пять-десять строк, иногда прямо в описании задачи. Это и есть оракул. Он написан человеком, который понимает домен, и он ничего не знает о будущей реализации.
Дальше роли распределяются естественно. Человек отвечает за то, что проверять и какой ответ правильный. AI отвечает за то, как это оформить: фикстуры, фабрики тестовых данных, setup и teardown, параметризация, обвязка вокруг тестового фреймворка. Это ровно та работа, которую не жалко отдать: механическая, легко проверяемая, без доменного суждения. А ожидаемые значения в assertions приходят из человеческого списка, а не из прочтения кода.
Важная деталь — порядок контекста. Если модель видит одновременно и требования, и реализацию, она всё равно склонна тянуться к реализации, потому что код конкретнее текста. Поэтому тесты по спецификации лучше генерировать до того, как код написан, или хотя бы в отдельной сессии, где реализации в контексте нет. Это звучит как бюрократия, но на деле занимает пару минут и меняет качество результата радикально.
Мутационное мышление как быстрый детектор пустых тестов
Как понять, что набор тестов чего-то стоит, если coverage ничего не говорит? Самый честный способ — mutation testing: инструмент вносит в код мелкие изменения (меняет > на >=, убирает условие, подменяет константу) и смотрит, упадёт ли хоть один тест. Если мутант выжил, значит, это поведение никто не проверяет. Инструменты вроде Stryker для JavaScript и TypeScript или PIT для JVM существуют давно, и для критичных модулей их стоит просто включить.
Но даже без инструмента полезно держать в голове мутационный вопрос при ревью любого теста: «какую ошибку в коде этот тест поймает?» Если ответить нечего — тест ничего не стоит. Если ответ «он поймает, что кто-то поменял имя метода» — это тест на реализацию, а не на поведение. Хороший тест можно описать через конкретный баг, от которого он защищает: «если скидка начнёт суммироваться с промокодом, упадёт вот этот кейс».
Этот же вопрос можно задать и модели, и тут AI неожиданно оказывается полезен с другой стороны. Попросите её не написать тесты, а предложить мутации кода, которые текущий набор пропустит. С этой задачей модели справляются заметно лучше: искать слабые места в чужой проверке им проще, чем придумывать правильные ожидания без требований. Получается не генератор тестов, а критик тестов, и в этой роли он реально экономит время.
Ревьюить тесты строже, чем код
Сложилась странная практика: код в pull request читают внимательно, а тесты пролистывают, особенно если они сгенерированы и их много. Логика понятна — тесты кажутся вспомогательным артефактом, и раз они зелёные, значит, всё в порядке. С AI-тестами эту логику нужно перевернуть. Тест — это формализованное утверждение о том, как система должна себя вести. Если утверждение ложное, оно будет охранять ошибку годами.
На ревью я смотрю в первую очередь не на количество кейсов, а на источник ожидаемых значений. Откуда взялось это число в assertion? Если его можно объяснить из требований — хорошо. Если единственное объяснение «так возвращает функция» — это красный флаг. Второе, на что стоит смотреть, — что замокано. Каждый мок — это место, где тест перестаёт проверять реальность. Моков должно быть ровно столько, сколько нужно, чтобы изолировать внешние системы, а не столько, сколько зависимостей у функции.
Третье — объём. Сто сгенерированных тестов, из которых девяносто проверяют одно и то же разными словами, хуже двадцати осмысленных. Они замедляют CI, засоряют дифф и создают ощущение тщательности, которой нет. Удалять лишние сгенерированные тесты — нормальная и полезная часть ревью, а не неуважение к чужой работе.
Когда тесты по коду всё-таки уместны
Важно не свалиться в другую крайность и не объявить любые тесты, выведенные из реализации, вредными. Есть как минимум один сценарий, где они ровно то, что нужно, — characterization tests для легаси. Если у вас есть старый модуль без тестов, который работает в проде и который нужно отрефакторить, то задача как раз в том, чтобы зафиксировать текущее поведение, включая странности. Здесь AI-генерация по коду — отличный инструмент: она быстро строит сетку безопасности, внутри которой можно менять структуру.
Но и тут есть условие: такие тесты нужно явно помечать как фиксацию поведения, а не как спецификацию. Они говорят «так было», а не «так правильно». Когда в процессе рефакторинга обнаруживается, что одно из зафиксированных поведений — баг, тест нужно осознанно поменять, а не воспринимать его падение как регрессию. Если эту разницу не проговорить в команде, через полгода никто не вспомнит, какие тесты охраняют требования, а какие — исторические случайности.
Цена подхода «требования сначала» тоже реальна. Он медленнее на старте, требует от разработчика формулировать ожидания до реализации, а это неудобно, когда задача исследовательская и требования проясняются по ходу. Для прототипов и одноразовых скриптов он избыточен. Но для бизнес-логики, расчётов, правил доступа и всего, что живёт долго и стоит дорого при ошибке, эти пара минут на список кейсов окупаются многократно.
Итог
Сгенерированные тесты не плохие сами по себе. Плох процесс, в котором источником правды для теста становится проверяемый код. В таком процессе AI выдаёт много аккуратных проверок, которые подтверждают, что код делает то, что делает, и поднимают coverage, не поднимая уверенности. Это не ускорение тестирования, а его имитация, и чем красивее отчёты, тем сложнее её заметить.
Рабочая схема выглядит скромнее, чем обещания «AI напишет все тесты». Человек формулирует, что должно быть правдой, — списком кейсов, acceptance criteria, хотя бы парой строк в задаче. AI превращает это в код тестов и берёт на себя бойлерплейт. Ревью проверяет происхождение каждого ожидаемого значения и задаёт мутационный вопрос: какую ошибку этот тест поймает. А для легаси тесты по коду остаются честным инструментом фиксации поведения — при условии, что их не путают со спецификацией.
Если свести всё к одному практическому правилу: ожидаемое значение в тесте должно приходить из требований, а не из реализации — отдавайте AI оформление тестов, но никогда не отдавайте ему решение о том, какой ответ правильный. Всё остальное в тестах можно автоматизировать без сожалений.