Rivalry2

HTML Diff

0 added 0 removed

Original 2026-01-01

Modified 2026-02-21

1 <a>#статьи</a>

2 <ul><li>9 сен 2021</li>

3 <li>0</li>

4 </ul><h2>Что такое юнит-тесты и почему они так важны</h2>

5 Бывает, кодишь 10 минут, а дебажишь 2 часа. Чтобы такого не случилось, пилите юнит-тесты. Михаил Фесенко рассказал, как их правильно готовить.

6 Oli Scarff / Staff / GettyImages

7 Журналист, коммерческий автор и редактор. Пишет про IT, цифровой маркетинг и бизнес. Сайт:<a>darovska.com</a>.

8 об авторе

9 Фесенко Михаил, можно просто Фес. Разработчик, раньше работал системным администратором, пишет на чём скажут, но пока писал на PHP, Go, Python, Bash. Сейчас работает в "Яндекс.Облаке", до этого работал во "ВКонтакте". Любит жену, кино и снимать видео =)

10 Юнит-тест (unit test), или модульный тест, - это программа, которая проверяет работу небольшой части кода. Разработчики регулярно обновляют сайты и приложения, добавляют фичи, рефакторят код и вносят правки, а затем проверяют, как всё работает.

11 Тестировать систему целиком после каждого обновления - довольно муторно и неэффективно. Поэтому обновлённые или исправленные части кода прогоняют через юнит-тесты.

12 На практике используют разные тесты - их разделяют по уровню абстракции с помощью пирамиды Майка Кона:

13 Изображение:<a>OTUS</a>Чем выше тест в пирамиде, тем больше частей программы он затрагивает. Высокоуровневые тесты "ближе к бизнесу": они проверяют бизнес-логику и пользовательские процессы. А те, что внизу пирамиды, помогают найти проблемы в отдельных частях кода. Например, какую-нибудь функцию, которая генерирует имя файла.

14 Большая часть тестов работает на верхних уровнях и не позволяет точечно отлавливать баги. Те же интеграционные тесты проверяют, как взаимодействуют между собой разные системы. А Е2Е-тесты исследуют процессы со стороны пользователя: например, когда он регистрируется и логинится на сайте.

15 В отличие от них, юнит-тесты нужны в следующих случаях:

16 <ul><li>если код непонятен - на ревью возникли вопросы по его работе;</li>

17 <li>если код часто меняется - чтобы не проверять его вручную;</li>

18 <li>если обновления в одной части кода могут сломать что-то в другой части.</li>

19 </ul>Некоторые программисты пишут только юнит-тесты, а на интеграционные или E2E-тесты жалеют времени. На самом деле нужно покрывать систему всеми видами тестов, чтобы знать, как взаимодействуют друг с другом разные части программы, какие промежуточные результаты они выдают. Но в то же время, если юнит-тесты показывают ошибку, её покажет и интеграционный, и E2E-тест.

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

21 Простой пример: у нас есть функция на Go, которая получает id бэкапа и возвращает имя бэкап-файла:

22 Код в Pastebin:<a>https://pastebin.com/ufeyuw3m</a>Протестируем её с помощью набора входных и выходных данных. Они должны учитывать все ситуации, поэтому не забываем про негативные кейсы - когда программа возвращает ошибку. Вот набор тестовых данных:

23 Код в Pastebin:<a>https://pastebin.com/Gy3h0Ppp</a>В первую очередь я прописал запрещённые данные (-1 и 0) и слишком большое значение (10200300). Когда пользователь их вводит, функция не должна возвращать результат. Вместо этого мы ждём сообщения об ошибке: BAD_ID или BACKUP_ID_TOO_BIG. Когда же функция получает валидный id, она выводит отформатированное имя файла, например Backup#000010.

24 А вот и код самого теста:

25 Порой код для тестирования даже больше основного - и это норма. Но иногда всё-таки стоит задуматься, на самом ли деле тест должен быть таким объёмным. Я бы посоветовал покрывать тестами только те фрагменты кода, которые вы планируете менять. Или сложные части, которые, скорее всего, придётся чинить или поддерживать.

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

27 В старой хорошей книге "<a>Экстремальное программирование</a>" есть классная мысль: сначала пишите тест, а только потом программу. Это клёвый подход, но не все могут так делать (а кто-то просто не хочет тратить время).

28 Есть разработчики, которые не проводят модульное тестирование: "Ой, у нас большой проект, и переписать 1000 строк под тесты или замокать их - слишком запарно". На самом деле покрыть код тестами несложно. Вот несколько советов.

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

30 Есть более жёсткий принцип:новый код без тестов на ревью не принимается. Конечно, он работает, если сроки не горят, - иначе программист рефакторит или покрывает его тестами позже.

31 Используйте тестовый фреймворк.В тестировании не нужно изобретать велосипед. Для популярных языков уже есть готовые решения, поэтому достаточно вбить в поиске test frameworks, и вы получите целый список. Вот, например, результат для Python:

32 Скриншот: портал<a>Software Testing Help</a>Пишите простые тесты.Надо понимать, что происходит с входными данными и какой результат должна вернуть функция. Если непонятно - меняем нейминг и разбиваем функции на более мелкие, избавляемся от зависимостей. Пусть одна функция принимает результат, а другая возвращает. Так проще тестировать.

33 Допустим, у нас есть такая функция:

34 Func processdata() { result_a = process_a() result_b = process_b(result_a) return prepare_output(result_b) }Её не нужно прогонять через юнит-тест, потому что тогда придётся мокать process_a, process_b и prepare_output. Тут нужен интеграционный тест, который проверит, как эти компоненты взаимодействуют между собой. Вообще, если код сложно покрывать юнит-тестами, используйте интеграционные - они проверяют общую работу системы, модуля или библиотеки.

35 Не забывайте про негативные тесты.Это the best practice. Что произойдёт, если передать в программу неправильные данные? Какую ошибку она выведет и выведет ли?

36 Покрывайте тестами все циклы и if-else.Этот совет касается кода, который нужно поддерживать. Если ему не следовать, на одной из итераций правок вы или ваш коллега просто всё сломаете.

37 Проверяйте качество тестов.Сделать это поможет мутационное тестирование. Мутационный фреймворк случайно меняет константы и значения в условных операторах и циклах, создаёт копию кода, в которой поочерёдно меняет условия. Например, было <=, а стало >= или было COUNT=3, а стало COUNT=10. Каждая замена тестируется: если код поменялся, а тесты не упали, значит, код не покрыт тестами.

38 На мутационное тестирование уходит много времени. Можно подключить плагин, который считает code coverage по тесту и выдаёт отчёт. Например, у нас покрыто тестами 43 тысячи строк кода, а 10 тысяч - нет. Значит, code coverage 81%. Но тут важен не только сам процент, но и качество - какие именно фрагменты кода и какими именно тестами покрыты. Например, не всё может быть под юнит-тестами - часть может перекрываться интеграционными.

39 Обеспечьте достаточный процент покрытия кода.Года три-четыре назад я был фанатиком стопроцентного покрытия. Конечно, безумно круто, когда ты всегда знаешь, что именно сломалось. Но в продакшне этого добиться сложно - да и не нужно. Исключение - маленькие проекты или "жёсткие" команды, для которых полное покрытие в приоритете.

40 На самом деле, code coverage в 70-90% - уже крутой показатель, но и меньше 70% - тоже плохо. И ещё важный момент: новый код не должен понижать уровень code coverage.

41 Проверить code coverage можно с помощью<a>coveralls.io</a>:

42 В файле github.go покрытие выросло. Скриншот: предоставлен авторомCoveralls принимает результаты тестов и выдаёт отчёт: показывает процент покрытия и как он изменился с последнего теста.

43 Здесь нет негативного теста, поэтому сервис выделил фрагмент красным цветом. Скриншот: предоставлен авторомНе делайте хрупкие тесты.Если тест нестабильный и регулярно падает, его называют хрупким. Его результат может зависеть от дня недели, времени суток, чётности или нечётности запуска. Бывает, две функции работают параллельно и на итоговый результат влияет то, какая из них закончит выполняться первой. Такие функции лучше разбивать на несколько простых и тестировать по отдельности. Мокайте всё что нужно, чтобы сделать тест управляемым, но не переборщите - иначе код будет сложно поддерживать.

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

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

46 Следите за скоростью тестов.Тесты должны работать быстро. Если они проверяют кусок кода 10-15 минут - разработчики устанут ждать и отключат их нафиг. Поэтому регулярно проверяйте скорость, ищите узкие места и оптимизируйте тесты. Если есть проблемы, подключитесь через дебаггер - возможно, основной код плохо оптимизирован и искать проблему нужно в продакшне.

47 Если у вас ещё остались сомнения, писать юнит-тесты или нет, вот несколько аргументов за. Итак, чем полезны юнит-тесты.

48 Упрощают работу-находят ошибки, которые вы можете не заметить (меня это много раз спасало). Например, меняешь одну строчку, чтобы поправить логи, а ломается весь код. Благодаря тестам я узнавал об этом ещё до продакшна.

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

50 Помогают ничего не сломать при рефакторинге.Бывает, что код написан непонятно и ты не можешь его отрефакторить, потому что наверняка что-то сломаешь в продакшне. А с тестами код можно смело рефакторить.

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

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

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

54 Современные компании подписывают SLA - гарантируют работоспособность сервиса. Если продукт упадёт, бизнесу придётся заплатить деньги. Поэтому лучше подождать тестов и не катить код, который положит весь продакшн. Даже если сайт или приложение пролежат всего две минуты, это ударит по репутации и дорого обойдётся компании.

55 Чтобы лучше понять юнит-тесты, изучите тестовые фреймворки вашего языка. А потом найдите крупные open-source-проекты, которые их используют, и посмотрите, как они работают. Можно даже скачать проект и поиграть с тестами, чтобы глубже погрузиться в тему.

56 У фреймворков разный подход к написанию тестов, вызову методов, мокам и неймингу. Плюс у каждого из них есть сторонники и хейтеры, поэтому пробуйте и выбирайте. Главное - чтобы фреймворк хорошо мокал ваш код. Например, если у вас специфичный ORM, убедитесь, что фреймворк умеет с ним работать.

57 Чтобы познать тонкости разработки и тестирования приложений, лучше сразу учиться у практикующих профессионалов. Приходите в университет Skillbox,<a>выбирайте курс</a>и осваивайте программирование под присмотром экспертов.

58 <a>Бесплатный курс по Python ➞Мини-курс для новичков и для опытных кодеров. 4 крутых проекта в портфолио, живое общение со спикером. Кликните и узнайте, чему можно научиться на курсе. Смотреть программу</a>