Что я тестирую, а что намеренно нет
Разговоры о тестах обычно начинаются с неправильного вопроса: «какое у нас покрытие?».
Вопрос плохой, потому что ответ на него ничего не значит. Я видел наборы тестов со стопроцентным покрытием, которые не ловят ни одной реальной ошибки. Они доказывают ровно одно: код работает так, как написан. А это вы и так знаете.
Правильный вопрос звучит иначе: какой код, сломавшись, я обязан заметить?
Три вида кода
В любом проекте код можно разделить на три группы, и отношение к каждой разное.
Первая группа — правила. Расчёт цены, применение скидки, вычисление процента посещаемости, проверка прав. Этот код чистый: на вход данные, на выход результат. Тестировать его легко, а поломка обходится дорого.
Это самое полезное место для тестов. Сюда я вкладываю большую часть усилий.
Вторая группа — соединения. Запросы к базе, HTTP-обработчики, вызовы внешних API. Логики тут мало, но ошибок много: неправильное имя поля, забытый await, не тот статус-код.
Покрывать эту группу юнит-тестами обычно бесполезно: вы подставляете мок вместо базы и в итоге тестируете собственный мок. Здесь нужны интеграционные тесты — с настоящей базой.
Третья группа — связующий код. Чтение конфигурации, сборка объектов, простые проброски. Если он сломается, это станет ясно на сборке или на первом же запросе.
Эту группу я намеренно не тестирую. Тесты для неё отнимают время, ничего не ловят и первыми мешают при рефакторинге.
Когда мок вредит
Мок — самый злоупотребляемый инструмент в тестировании.
Причина понятна: он делает тесты быстрыми и простыми. Проблема в том, что, написав мок, вы фиксируете своё предположение о том, как работает система. Если предположение неверно, тест зелёный, а прод падает.
Практический пример. Вы мокаете запрос к базе так, что он возвращает массив. Тест проходит. А в проде ORM на пустом результате возвращает null, и код падает именно здесь. Тест не мог поймать эту ошибку, потому что проверял не реальность, а ваше представление о ней.
Моё правило такое: я не мокаю собственный код. Моки — только на границах, которые я не контролирую: платёжная система, отправка SMS, внешний API.
Вместо мока базы я использую настоящую базу. Поднимается один контейнер в Docker, прогоняются миграции, проходят тесты, контейнер гасится. Это медленнее — зато результат отражает реальность.
Что должен проверять тест
Самая частая ошибка — привязывать тест к реализации.
Плохой тест:
it('внутри calculateDiscount вызывается applyRule', () => {
const spy = vi.spyOn(rules, 'applyRule')
calculateDiscount(order)
expect(spy).toHaveBeenCalled()
})Такой тест замораживает внутреннюю структуру кода. Завтра вы переименуете applyRule или перенесёте логику внутрь — и тест упадёт, хотя поведение не изменилось.
Хороший тест:
it('даёт 10% скидки на заказ больше 5 позиций', () => {
expect(calculateDiscount({ items: 6, total: 100000 })).toBe(90000)
})Этот тест проверяет результат. Переписывайте внутренности сколько угодно — тест будет помогать, а не мешать.
Простая проверка: если при рефакторинге вы вынуждены править и тест, значит, тест написан не на том уровне.
Граничные случаи — основная ценность
Настоящая ценность набора тестов не в сценарии «всё работает правильно». Его вы и так проверите руками.
Ценность — на границах:
- Пустой список. Чему равно среднее при нуле элементов?
- Пограничное число. Если скидка «больше 5», что происходит ровно на 5?
- Отсутствующие данные. И
null, иundefined. - Повторный вызов. Если отправить один и тот же запрос дважды, создастся ли два заказа?
- Границы времени. Последний день месяца, смена года, граница четверти.
Последнее особенно важно в школьной системе: границы четверти и учебного года влияют почти на каждый отчёт, и ломаются они именно в пограничные дни.
Когда не писать тесты — тоже правильно
Эту часть говорить неловко, но стоит быть честным: тесты нужны не каждому проекту.
Когда я писал систему комментариев для собственного блога, я намеренно не стал писать юнит-тесты. Причины были ясные: объём кода маленький, логики почти нет, цена ошибки низкая (если комментарий не отобразится, никто не пострадает), и пишу я это один раз.
Это время я потратил на другое — на ручную проверку прав доступа в базе по конкретным сценариям. Потому что там цена ошибки действительно высокая.
Критерий решения такой: цена ошибки × вероятность повторения. Если оба низкие, не писать тесты — правильное инженерное решение, а не лень.
И наоборот: в скрипте управления окнами, который я писал для KWin, 22 теста. Там сложная логика, много граничных случаев и высокий риск регрессии при каждом изменении. Тот же человек, тот же месяц — совершенно другое решение.
С чего начать на практике
Если тестов в проекте нет совсем, не пытайтесь покрыть всё. Начните так:
- Найдите расчётную функцию, сильнее всего связанную с деньгами или доверием. Напишите на неё тесты с граничными случаями.
- Возьмите последнюю ошибку, вылезшую в проде, и напишите тест, который её воспроизводит. Такой тест даёт пользу сразу.
- Напишите интеграционные тесты на три самых важных HTTP-потока — с настоящей базой.
- Остановитесь и проживите с этим месяц.
Потом посмотрите: какие тесты действительно вас спасли, а какие только мешали рефакторингу. Вторую группу удалите.
Набор тестов — это код, а любой код является расходом. Смотрите на него как на вложение: не вкладывайте туда, где нет отдачи.