Агрессивная регрессия
· 14 min read
testing elixir programming opinion ai llm hacking
Существует особая порода инженеров, которая на вопрос о наличии регрессионных тестов в проекте с гордостью отвечает: «у нас девяносто четыре процента покрытия». Это примерно то же самое, что на вопрос «застрахован ли ваш дом от пожара?» ответить: «у меня одиннадцать датчиков дыма, и я каждую неделю протираю их тряпочкой». Оба утверждения вращаются в одной и той же понятийной области, но между ними нет даже отдалённого родства, и лишь одно из них будет иметь значение в ту ночь, когда на кухне заполыхает проводка.
Позвольте сразу зафиксировать главный тезис — в надежде, что он доберётся до секции комментариев неповреждённым:
Всякий регрессионный тест — это тест, но не всякий тест — регрессионный.
Это не просто броский афоризм. Это строгое утверждение о теории множеств, и это именно то утверждение, с которым большинство команд согласно кивает, чтобы затем немедленно нарушать его следующие четыре года.
Таксономия, которую никто не захотел выучить
Тест — это любой фрагмент кода, который падает, когда что-то сломалось. Регрессионный тест — это фрагмент кода, который падает, когда то, что раньше работало , вдруг перестает работать. Вторая категория — строгое подмножество первой, и это куда меньшее подмножество, чем пытается убедить вас бейджик покрытия в репозитории.
Вся суть заключена в слове «раньше». Регрессионный тест — это памятник. Он увековечивает конкретный момент истории, когда софт был доподлинно корректен, и несёт караул над этим моментом до тех пор, пока проект дышит. Это, в самом буквальном смысле, институциональная память, закодированная в исполняемый артефакт — единственная память в вашей команде, которая не увольняется, не уходит на пенсию и не забывает всё на свете за длинные майские выходные.
Большая часть того, что мы пишем изо дня в день — совсем не об этом. Большая часть нашего кода — это разработчик, успокаивающий самого себя в два часа пополудни: мол, только что набранная им функция делает ровно то, что он воображал, пока барабанил по клавишам. Это вполне респектабельное занятие. Но это также и тавтология в белом лабораторном халате.
Юнит-тесты — это зеркала
Вот неудобная правда о среднестатистическом юнит-тесте: он утверждает, что реализация делает ровно то, что делает реализация. Автор написал функцию, затем написал тест, выведенный из только что написанной функции, а потом искренне обрадовался, когда они совпали. Они и не могли разойтись. Они были зачаты в одни и те же пять минут, одним и тем же мозгом, под влиянием одних и тех же иллюзий. Даже столь заурядный разработчик, как я, способен написать простую функцию без фатальных огрехов.
Юнит-тест обычно лезет глубоко внутрь. Он знает приватные вспомогательные функции модуля, структуру промежуточного аккумулятора, точный порядок обхода списка. Он интимен с деталями, которых ни один внешний вызывающий код никогда не увидит, и потому он до смешного хрупок именно там, где вам больше всего нужна свобода манёвра. Перепишите аккумулятор со списка на мапу, не изменив ни на йоту наблюдаемое поведение — и созерцайте, как сорок тестов заливаются красным, пока сам софт работает как часы. Это не страховочная сетка. Это растяжка, которую вы сами натянули у себя в прихожей.
И всё это здание держится исключительно на фантазии автора. Юнит-тест проверяет те три варианта входных данных, о которых автор успел подумать. Баг же, с безошибочным чутьем кота, выбирающего в комнате единственного гостя с аллергией, притаился в четвёртом.
Вот почему один-единственный тест на основе свойств (property-based test) стоит мешка рукописных примеров. Вместо того чтобы перечислять случайные озарения, вы декларируете закон, которому обязана подчиняться функция, а затем поручаете машине охоту за контрпримером с дотошностью, на которую ни один живой человек в четыре часа дня в пятницу не способен физически.
Взгляните на типичный рукописный подход:
test "encodes and decodes" do
assert "abc" == decode(encode("abc"))
assert "" == decode(encode(""))
assert "hello world" == decode(encode("hello world"))
end
Три ассерта, тщательно отобранных человеком, который уже знал, как устроен энкодер. А теперь сравните:
property "decode/1 is the left inverse of encode/1" do
check all input <- StreamData.string(:printable) do
assert input == input |> encode() |> decode()
end
end
Одно утверждение, бесконечно много проверок и — вот деталь, которую постоянно недооценивают — автоматический шринкер (минимизатор), который вручит вам минимальный ломающий ввод, а не простыню на 4 КиБ мусора, на которой споткнулся генератор. Вот это — сторожевой пёс. А первое — всего лишь фотография собаки, приколотая к забору.
Elixir не позволяет тестировать приватные функции, и это великое благо
Каждые пару месяцев на форумах появляется новичок с вопросом, оформленным как баг-репорт: «Как мне протестировать
defp
?». Ответы обычно терпеливы, а вопрошающий редко остаётся доволен, потому что честный ответ звучит как форменное издевательство:
никак, и вам не следует этого хотеть.
Приватная функция по определению не является частью контракта. Это строительные леса. Она существует лишь потому, что вам надоела функция на сорок строк и вы распилили её пополам, либо потому, что одни и те же три строчки понадобились дважды. Никто снаружи модуля не может её вызвать, никто снаружи модуля не может её наблюдать, и никому снаружи модуля не станет хуже от её полной замены. У неё нет поведения в значимом смысле слова — у неё есть лишь реализация, а реализацию, как мы только что договорились, тестировать не нужно.
Язык вовсе не кокетничает. Он прямым текстом сообщает: если вы чувствуете жгучую потребность протестировать приватную функцию изолированно, вы нащупали проблему в архитектуре, а не брешь в инструментарии. Верно одно из трёх:
Она должна быть публичной. То, что вы пытаетесь приколоть булавкой к столу — на самом деле часть контракта модуля, и вы прятали собственный API от самих себя из ложного чувства аккуратности. Сделайте её публичной, задокументируйте и тестируйте как публичную сущность, коей она всегда и являлась.
Она должна стать отдельным модулем. Приватный хелпер оброс индивидуальностью: собственным словарем терминов, собственными инвариантами, собственными поводами для изменений. Это модуль, который пытается родиться на свет. Примите роды. Теперь у него есть публичный интерфейс, и его тестирование больше не вызывает экзистенциального кризиса.
Её вообще не надо тестировать. Это три строчки сантехники между двумя публичными функциями, обе из которых покрыты тестами и обе взвоют, если эта сантехника лопнет. Оставьте её в покое. Каждый написанный тест — это строчка кода, которую вам придётся поддерживать до конца дней; тратить этот бюджет на приватный двухстрочник — всё равно что оформлять страховку на шнурки от ботинок.
Разумеется, пытливый ум всегда обнаружит, что до
Module.function
можно дотянуться с черного хода через
apply/3
и манипуляции с атрибутами, либо просто бахнуть
@compile :export_all
и жить дальше. Да, можно. А ещё можно срезать перила с балкона, потому что они загораживают красивый вид. Перила не были ошибкой архитектора.
Здесь кроется и второй, куда более тонкий подарок. Делая реализацию недоступной для прямого тестирования, язык мягко подталкивает ленивого разработчика — а в четверг после обеда мы все поголовно ленивые разработчики — к тестированию поведения. Того единственного, что вообще имеет смысл тестировать. Elixir возвёл хороший вкус в ранг ограничения компилятора. Мало у каких языков хватает на это духу.
Поведение — добродетель, реализация — порок
Вот механическая причина, по которой поведенческие тесты ловят регрессии, а тесты реализации — нет.
Регрессия случается тогда, когда кто-то меняет реализацию и случайно ломает поведение. Такова исчерпывающая анатомия бага. А теперь представьте, что происходит с каждым типом тестов при таком событии.
Тест реализации был написан под старую реализацию. Разработчик изменил реализацию, и тест упал — но упал он потому, что изменилась реализация, а не потому, что что-то непременно сломалось. Разработчик, человек разумный, торопящийся и уже раз девять за этот месяц наблюдавший ложные срабатывания этого теста, просто обновляет тест под новую реализацию. Тест зеленеет. Баг уезжает в прод. Тест с энтузиазмом поспособствовал собственному поражению.
Поведенческий тест был написан под контракт, менять который никто не собирался. Он падает, и «обновить» его на скорую руку невозможно, ведь обновление теста означало бы открытое признание: софт теперь ведёт себя иначе. А это уже повод для серьезного разговора, а не для минутного фикса. Баг в прод не попадает.
Именно поэтому у настоящего регрессионного теста совершенно особая родословная. Его не пишет сияющий разработчик во время запила новой фичи. Его пишет человек с мрачным лицом по следам недавнего инцидента, и читается такой тест как протокол допроса:
describe "issue #1472: timezone-aware expiry" do
test "a token minted at 23:59 UTC is not considered expired at 00:01 local" do
# Зарепорчено 2026-04-02 клиентом в UTC+2, у которого вся
# команда разлогинивалась каждую ночь на протяжении девяти дней.
token = mint_token(at: ~U[2026-04-02 23:59:00Z], ttl: {2, :hour})
assert {:ok, _claims} = verify(token, now: ~U[2026-04-03 00:01:00Z])
end
end
Посмотрите, что этот тест знает, а чего не знает. Он знает симптом, дату и жертву. Он понятия не имеет, как именно вычисляется экспирация: через
DateTime.diff/3
, закешированное монотонное смещение или солнечные часы. Завтра вы можете переписать всю подсистему авторизации с нуля; этот тест молча пойдёт за вами, и в тот день, когда он покраснеет — сломалось действительно что-то важное.
Обратите внимание и на комментарий. Регрессионный тест без предыстории своего появления — противопехотная мина для следующего разработчика, который посмотрит на странный ассерт, не сможет представить, зачем его вообще написали, и просто удалит. Каждый регрессионный тест обязан нести в себе некролог того бага, который он похоронил. Самая дешёвая документация в проекте — та, которая ломает билд, как только перестаёт быть правдой.
Правило без оговорок: каждое исправление бага сопровождается тестом, который падает до фикса и проходит после него. Если вы не можете написать падающий тест — вы не поняли баг; вы лишь спугнули его, и он обязательно вернётся.
И тут пришли машины
Всё сказанное выше оставалось чистой правдой примерно с 1975 года. Что изменилось — так это объём и происхождение кода, льющегося в наши репозитории.
Сгенерированный код плох вовсе не тем, о чём обычно твердят пессимисты. Он опасен куда более конкретной и коварной чертой: он
локально правдоподобен и глобально оторван от контекста
. У модели, делающей рефакторинг, нет памяти об апрельском инциденте. Её ни разу не будил пейджер в три часа ночи. Она не знает, что в цикле ретраев стоит странный
+1
, потому что чужой API считает с единицы, а на шаге нормализации вырезается специфический символ Юникода из-за бага в клиенте четырехлетней давности, которым до сих пор пользуются шестьсот клиентов. Все эти сакральные знания живут ровно в двух местах: в головах людей, которые рано или поздно уволятся, и в вашем регрессионном сьюте.
Когда живой инженер натыкается на странную строчку, он замирает в нерешительности. Он делает
git blame
. Он спрашивает в рабочем чате. Модель не сомневается — она физически не способна на сомнение, ведь для сомнения нужно понимать границы собственного незнания, а статистический усилитель органически не приспособлен к такой форме смирения. Модель видит шероховатость, распознаёт в ней отклонение от шаблонов из обучающей выборки и сносит её к чертям — с невозмутимой уверенностью уборщика, выбрасывающего в мусор концептуальную инсталляцию художника, потому что она показалась ему кучей хлама.
Ваш регрессионный сьют — единственное, что способно сказать этому нет . Не линтер, который посчитает причёсанную версию куда опрятнее. Не тайпчекер, который радостно подтвердит сходство типов. Не ревьюер, перед глазами которого диф на четыреста строк и встреча через шесть минут. Только тест, написанный тем, кто дежурил в апреле.
Это выворачивает экономику разработки наизнанку. Стоимость написания кода упала практически до нуля. Стоимость верификации кода не сдвинулась ни на йоту, потому что именно в верификации сосредоточено доменное знание, а доменное знание никогда не измерялось количеством нажатий на клавиши. Пропорции изменились. В 2015 году команда, выдававшая десять тысяч строк в год, могла позволить себе легкомысленное отношение к тестовому сьюту. Команда, выдающая десять тысяч строк в месяц, позволить себе этого не может. Не потому, что код стал хуже, а потому, что его больше не читает ни один живой человек, и тестовый сьют незаметно превратился из страховочной сетки в главного и единственного читателя.
Два следствия, от которых многих коробит:
Никогда не позволяйте модели писать регрессионный тест по уже исправленному коду. Весь смысл теста в том, что он выводится из симптома , совершенно независимо от реализации. Скормите модели запатченную функцию и попросите тесты — вы получите восхитительно детальное описание этого самого патча. Снова зеркало, просто более быстрое и грамотное. Сначала напишите падающий тест своими словами по баг-репорту. Затем скормите его машине и пусть правит код, пока тест не станет зелёным. Вот такое направление работы феноменально продуктивно. Обратное — дешёвый театр.
Относитесь с глубочайшим подозрением к зелёному сьюту после масштабного ИИ-рефакторинга.
Либо ваш сьют действительно поведенческий (в таком случае примите поздравления и идите обедать), либо он настолько жидок, что ни один тест в нём в принципе ничего не мог заметить. Проверить это просто: сломайте что-нибудь нарочно и убедитесь, что тесты взвоют. Если вы хотите делать это системно, а не на глазок — используйте мутационное тестирование: это тесты для ваших тестов, и первый запуск неизменно сбивает спесь. Попробуйте библиотеку
muex
— отличная вещь.
Другие экспонаты из дикой природы
Раз уж разговор зашёл, вот ещё несколько паттернов, обитающих по правильную сторону баррикад — и пара самозванцев.
Тесты характеризации для кода, который никто не понимает. Вы получаете в наследство сорок тысяч строк без тестов и без авторов. Написать поведенческие тесты вы не можете, потому что никто не знает, каким поведение должно быть. Вы фиксируете фактическое поведение: скармливаете реальные входные данные, записываете выходы и требуете, чтобы они оставались неизменными. Эти тесты не гарантируют корректность; они гарантируют стабильность — единственное, за что можно честно поручиться в системе, устройства которой вы не понимаете. Это чистейшая форма регрессионного тестирования и стандартная точка входа для безопасной работы с легаси. Помечайте такие тесты отдельно, ведь некоторые из них бережно консервируют баги, и однажды кто-то починит один из них и замрёт в недоумении перед красным экраном.
Доктесты как поведенческие контракты.
Elixir
doctest
— потрясающе радикальная идея: пример из документации
и есть
тест. Документация врёт непрерывно, в любом проекте и на любом языке — кроме тех мест, где за ложь ломается билд. А поскольку примеры в документации по определению пишутся с точки зрения пользователя, они поведенческие по самой своей сути. Вы не станете описывать промежуточный аккумулятор приватной функции в документации для пользователя, вы не станете этого делать — а значит, не станете и тестировать. Форма диктует содержание.
Контрактные тесты на границах сервисов. Регрессия, которая с наибольшей вероятностью пустит под откос ваш квартал, прячется вовсе не в вашем коде. Она сидит на том конце провода, где во вторник кто-то молча сменил тип поля со строки на число. Контрактный тест, завязанный на зафиксированное версионированное взаимодействие, поймает это на этапе CI, а не на проде. Поведение на стыке — именно там, где о нём труднее всего рассуждать и где ошибка обходится дороже всего.
Mox
и явные контракты против моков как самоцели.
Мокать приватную зависимость, чтобы проверить, что её вызвали ровно два раза — это тестирование реализации с кучей церемоний и невнятными сообщениями об ошибках. Объявить behaviour, реализовать его дважды (один раз по-настоящему, второй — для тестов) и проверять
контракт взаимодействия
— это поведенческое тестирование со сменным бэкендом. Первое превращает рефакторинг в ад; второе делает его возможным. Один инструмент, противоположные результаты — и вся разница лишь в том, чем был ваш мок: строгим контрактом или случайной деталью.
Флакающий (flaky) тест — это регрессионный тест на конкурентность, который вы игнорируете.
У каждой команды есть тест, который падает в CI раз в две недели, и у каждой команды на нём висит
@tag :skip
или обертка с повторными запусками. Этот тест не сломан. Этот тест — единственный во всём сьюте, кто сумел поймать состояние гонки, а вы заткнули ему рот кляпом. Недетерминизм в тестах почти всегда указывает на реальный недетерминизм в системе.
Время, локаль и кодировки: три всадника апокалипсиса.
Колоссальная доля всех зарегистрированных регрессий происходит из-за перехода даты через полночь, форматирования чисел в другой локали или символа в строке, о существовании которого автор даже не догадывался. Все они поведенческие по природе и почти никогда не покрываются рукописными тестами, ведь фантазия автора ограничена его часовым поясом, локалью и алфавитом. У генераторов свойств таких ограничений нет, поэтому
StreamData
находит эмодзи в поле логина примерно за девять итераций.
Золотые файлы (golden files) со смыслом.
Тестирование по снимкам (snapshots) пользуется дурной славой, заслуженной командами, которые на автомате жмут «обновить все снапшоты» и коммитят не глядя. Золотой файл, отрецензированный с той же строгостью, что и рабочий код — великолепный регрессионный тест для сущностей со сложной структурой вывода: отрендеренных шаблонов, сгенерированных схем, сериализованных данных. Золотой файл, обновляемый мышечной памятью — это просто
git add .
с лишними телодвижениями.
Бюджеты производительности.
Функция, которая возвращает правильный ответ за девять секунд вместо прежних сорока миллисекунд, испытала регрессию: поведение системы включает в себя и то, сколько времени у неё уходит на реакцию. Грубый ассерт на верхнюю границу времени выполнения или бенчмарк в CI отлавливает случайный
Enum.map
поверх запроса к базе данных, который кто-то опрометчиво засунул в цикл. Никто не пишет такие тесты до первой аварии, а жаль: стоят они копейки.
Тест, который вы удалили. Напоследок самое крамольное: тест, который за три года ни разу не упал по уважительной причине, вас не защищает. Это просто расходная статья в бюджете поддержки, лишнее время на CI и мелкий ежедневный налог на внимание инженеров. Регрессионный сьют должен прирастать реальными инцидентами, а не навязанными сверху квотами покрытия. Покрытие измеряет выполненные строки, а не проверенное поведение: набор тестов, вызывающий каждую функцию без единого ассерта, покажет сто процентов — ровно так же, как и набор, проверяющий всё подряд и не понимающий ничего.
Кратко
Обычные тесты дёшевы и многочисленны; регрессионные тесты дороги и редки, ведь каждый из них покупается ценой реальной аварии. Относитесь к ним соответственно. Пишите их от баг-репорта, а не от фикса. Нацеливайте их на контракт, а не на потроха реализации. Позвольте компилятору бить вас по рукам при попытке тестировать приватные функции и мысленно поблагодарите его за дисциплину. Предпочитайте общий закон единичному примеру и доверьте генератору поиск контрпримеров, до которых вы сами никогда бы не додумались.
И теперь, когда всё большая часть кода прибывает из источника, напрочь лишенного памяти о последних пяти годах, осознайте, чем стал ваш тестовый сьют. Это больше не просто этап контроля качества. Это единственная оставшаяся у вас институциональная память, которая не спит, не увольняется и которую невозможно сбить с толку парой складно написанных абзацев правдоподобных рассуждений.
Будьте агрессивны. Регрессии уж точно церемониться не станут.
Ранее на тему того, как не обманывать себя собственными инструментами: