Искусство юнит-тестирования с примерами на JavaScript, Ошеров Р., Хориков В., 2025

Искусство юнит-тестирования с примерами на JavaScript, Ошеров Р., Хориков В., 2025.
        
   Искусство юнит-тестирования не сводится к изучению правильного набора инструментов и практик. Искусство создавать классные тесты — это понимание сути, поиск верной стратегии для каждого конкретного случая и умение выйти из ситуации, когда тестирование превращается в беспорядочный процесс. Эта книга предлагает советы и рекомендации, которые полностью изменят ваш подход к тестированию ПО.
Вы научитесь создавать читабельные и простые в сопровождении тесты, изучите стратегии тестирования в масштабах организации, диагностику проблем, работу с унаследованным кодом и «бескомпромиссный» рефакторинг. Книга насыщена практическими примерами и знакомыми сценариями. Третье издание было дополнено методами, присущими объектно-ориентированному, функциональному и модульному стилю программирования. В примерах используются JavaScript. TypeScript и Node.js.




ХАРАКТЕРИСТИКИ ХОРОШЕГО ЮНИТ-ТЕСТА.
Какой бы язык программирования вы ни использовали, один из самых сложных вопросов — это определение того, какой же юнит-тест следует считать хорошим. Конечно, само понятие «хороший» относительно, и оно может изменяться каждый раз, когда вы узнаете что-то новое о программировании. Это может показаться очевидным, но на самом деле это не так. Я должен объяснить, почему нужно писать хорошие тесты, — понимать, что такое «единица работы», недостаточно.

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

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

ОГЛАВЛЕНИЕ.
Отзывы о втором издании.
Предисловие ко второму изданию.
Предисловие к первому изданию.
Введение.
Благодарности.
О книге.
Что нового в третьем издании.
Для кого эта книга.
Структура книги.
О коде в книге.
Программные требования.
Форум LiveBook.
Другие проекты Роя Ошерова.
Другие проекты Владимира Хорикова.
Об авторах.
Иллюстрация на обложке.
От издательства.
О научном редакторе русского издания.
Часть I. Первые шаги.
Глава 1. Основы юнит-тестирования.
1.1. Первый шаг.
1.2. Определение юнит-тестирования шаг за шагом.
1.3. Точки входа и точки выхода.
1.4. Типы точек выхода.
1.5. Разные точки выхода, разные методы.
1.6. Написание теста с нуля.
1.7. Характеристики хорошего юнит-теста.
1.7.1. Как выглядит хороший юнит-тест?.
1.7.2. Чек-лист юнит-теста.
1.8. Интеграционные тесты.
1.9. Окончательное определение.
1.10. Разработка через тестирование.
1.10.1. TDD не заменит хорошие юнит-тесты.
1.10.2. Три основных навыка, необходимых для успешного применения TDD.
Итоги.
Глава 2. Первый юнит-тест.
2.1. Знакомство с Jest.
2.1.1. Подготовка среды.
2.1.2. Подготовка рабочего каталога.
2.1.3. Установка Jest.
2.1.4. Создание файла теста.
2.1.5. Выполнение Jest.
2.2. Библиотека для тестирования, библиотека утверждений, запуск тестов и представление отчета.
2.3. Что предлагают фреймворки юнит-тестирования.
2.3.1. Фреймворки xUnit.
2.3.2. Структуры xUnit, TAP и Jest.
2.4. Проект Password Verifier.
2.5. Первый тест Jest для verifyPassword.
2.5.1. Паттерн «подготовь — действуй — проверь».
2.5.2. Тестируем тест.
2.5.3. Имена USE.
2.5.4. Сравнения строк и сопровождаемость.
2.5.5. Использование describe().
2.5.6. Структура, подразумевающая контекст.
2.5.7. Функция it().
2.5.8. Две разновидности Jest.
2.5.9. Рефакторинг рабочего кода.
2.6. Решение с beforeEach().
2.6.1. beforeEach() и утомительная прокрутка.
2.7. Решение с фабричным методом.
2.7.1. Полная замена beforeEach() фабричными методами.
2.8. Возвращение к test().
2.9. Рефакторинг: параметризованные тесты.
2.10. Проверка ожидаемых ошибок.
2.11. Назначение категорий тестов.
Итоги.
Часть 2. Приемы и методы.
Глава 3. Устранение зависимостей при помощи стабов.
3.1. Типы зависимостей.
3.2. Причины для использования стабов.
3.3. Общепринятые подходы к созданию стабов.
3.3.1. Создание стаба для времени с внедрением параметра.
3.3.2. Зависимости, внедрения и контроль.
3.4. Функциональные методы внедрения.
3.4.1. Внедрение функции.
3.4.2. Внедрение зависимости через частичное применение.
3.5. Модульные методы внедрения.
3.6. Переход к объектам с функциями-конструкторами.
3.7. Объектно-ориентированные методы внедрения.
3.7.1. Внедрение через конструктор.
3.7.2. Внедрение объекта вместо функции.
3.7.3. Выделение общего интерфейса.
Итоги.
Глава 4. Тестирование взаимодействий с использованием моков.
4.1. Тестирование взаимодействий, моки и стабы.
4.2. Зависимость от логгера.
4.3. Стандартный стиль: рефакторинг с введением параметра.
4.4. Почему важно отличать моки от стабов.
4.5. Моки в модульном стиле.
4.5.1. Пример рабочего кода.
4.5.2. Рефакторинг рабочего кода в стиле модульного внедрения.
4.5.3. Пример теста с внедрением в модульном стиле.
4.6. Моки в функциональном стиле.
4.6.1. Использование стиля каррирования.
4.6.2. Работа с функциями высшего порядка без каррирования.
4.7. Моки в объектно-ориентированном стиле.
4.7.1. Рефакторинг рабочего кода для внедрения.
4.7.2. Рефакторинг рабочего кода с внедрением интерфейсов.
4.8. Сложные интерфейсы.
4.8.1. Пример сложного интерфейса.
4.8.2. Написание тестов со сложными интерфейсами.
4.8.3. Недостатки прямого использования сложных интерфейсов.
4.8.4. Принцип разделения интерфейсов.
4.9. Частичные моки.
4.9.1. Пример частичного мока.
4.9.2. Объектно-ориентированный пример частичного мока.
Итоги.
Глава 5. Изолирующие фреймворки.
5.1. Определение изолирующих фреймворков.
5.1.1. Выбор разновидности: свободные и типизированные.
5.2. Динамическое создание фейков для модулей.
5.2.1. Некоторые особенности API Jest, на которые следует обратить внимание.
5.2.2. Абстрагирование прямых зависимостей.
5.3. Функциональные динамические моки и стабы.
5.4. Объектно-ориентированные динамические моки и стабы.
5.4.1. Использование фреймворка со свободной типизацией.
5.4.2. Переход на фреймворк с поддержкой типов.
5.5. Динамическое создание стабов.
5.5.1. Объектно-ориентированный пример с моком и стабом.
5.5.2. Стабы и моки с substitute.js.
5.6. Преимущества и опасности изолирующих фреймворков.
5.6.1. Моки в большинстве случаев не нужны.
5.6.2. Нечитаемый код теста.
5.6.3. Проверка не того, что нужно.
5.6.4. Наличие более одного мока на тест.
5.6.5. Излишняя детализация тестов.
Итоги.
Глава 6. Юнит-тестирование асинхронного кода.
6.1. Асинхронная загрузка данных.
6.1.1. Первая попытка написания интеграционного теста.
6.1.2. Ожидание действия.
6.1.3. Интеграционное тестирование async/await.
6.1.4. Проблемы с интеграционными тестами.
6.2. Создание кода, удобного для юнит-тестов.
6.2.1. Выделение точки входа.
6.2.2. Паттерн «выделение адаптера».
6.3. Таймеры.
6.3.1. Создание стабов для таймеров.
6.3.2. Фейки setTimeout средствами Jest.
6.4. Распространенные события.
6.4.1. Генераторы событий.
6.4.2. События click.
6.5. Использование DOM Testing Library.
Итоги.
Часть 3. Код тестов.
Глава 7. Достоверные тесты.
7.1. Как определить, что тесту можно доверять.
7.2. Почему тесты не проходят.
7.2.1. В рабочем коде была обнаружена реальная ошибка.
7.2.2. Тест не проходит из-за ошибки в самом тесте.
7.2.3. Тест устарел из-за изменения в функциональности.
7.2.4. Тест конфликтует с другим тестом.
7.2.5. Ненадежность теста.
7.3. Избегание логики в юнит-тестах.
7.3.1. Логика в утверждениях: создание динамических ожидаемых значений.
7.3.2. Другие формы логики.
7.3.3. Еще больше логики.
7.4. Ложное чувство доверия к проходящим тестам.
7.4.1. Тесты, которые ничего не проверяют.
7.4.2. Тесты непонятны.
7.4.3. Смешение юнит-тестов с ненадежными интеграционными тестами.
7.4.4. Тестирование нескольких точек выхода.
7.4.5. Тесты, которые продолжают изменяться.
7.5. Ненадежные тесты.
7.5.1. Что делать при обнаружении ненадежного теста?.
7.5.2. Предотвращение ненадежности в высокоуровневых тестах.
Итоги.
Глава 8. Простота в сопровождении.
8.1. Изменения из-за непроходящих тестов.
8.1.1. Тест неактуален или конфликтует с другим тестом.
8.1.2. Изменения в API рабочего кода.
8.1.3. Изменения в других тестах.
8.2. Рефакторинг для улучшения сопровождаемости.
8.2.1. Избегайте тестирования приватных или защищенных методов.
8.2.2. Соблюдение принципа DRY в тестах.
8.2.3. Нежелательность подготовительных методов.
8.2.4. Использование параметризованных тестов для устранения дублирования.
8.3. Избегайте излишней детализации.
8.3.1. Излишняя детализация внутреннего поведения с моками.
8.3.2. Излишняя детализация выводов.
Итоги.
Часть 4. Проектирование и процесс.
Глава 9. Читабельность.
9.1. Выбор имен юнит-тестов.
9.2. Магические значения и имена переменных.
9.3. Отделение проверок от действий.
9.4. Подготовка и завершение.
Итоги.
Глава 10. Разработка стратегии тестирования.
10.1. Основные виды и уровни тестирования.
10.1.1. Критерии для выбора вида теста.
10.1.2. Юнит-тесты и компонентные тесты.
10.1.3. Интеграционные тесты.
10.1.4. Тесты API.
10.1.5. Изолированные тесты E2E/UI.
10.1.6. Системные тесты E2E/UI.
10.2. Антипаттерны в разработке стратегии тестирования.
10.2.1. Антипаттерн «только сквозные тесты».
10.2.2. Антипаттерн «только низкоуровневые тесты».
10.2.3. Рассоединение низкоуровневых и высокоуровневых тестов.
10.3. Рецепты тестирования как стратегия.
10.3.1. Как написать рецепт тестирования.
10.3.2. Когда писать и использовать рецепты тестирования?.
10.3.3. Правила составления рецептов тестирования.
10.4. Управление конвейером поставки ПО.
10.4.1. Конвейеры поставки и информационные конвейеры.
10.4.2. Параллелизация уровней тестирования.
Итоги.
Глава 11. Интеграция юнит-тестирования в организацию.
11.1. Как стать инициатором изменений.
11.1.1. Подготовьтесь к непростым вопросам.
11.1.2. Убедите окружающих: сторонников и скептиков.
11.1.3. Определите возможные отправные точки.
11.2. Пути к успеху.
11.2.1. Партизанская реализация (снизу вверх).
11.2.2. Привлечение руководства (сверху вниз).
11.2.3. Эксперименты как первый шаг.
11.2.4. Привлечение внешнего сторонника.
11.2.5. Демонстрация прогресса.
11.2.6. Ориентация на конкретные цели, метрики и KPI.
11.2.7. Понимание возможных препятствий.
11.3. Возможные неудачи.
11.3.1. Недостаточный направляющий импульс.
11.3.2. Недостаток политической поддержки.
11.3.3. Ситуативные реализации и первые впечатления.
11.3.4. Недостаток поддержки в команде.
11.4. Факторы влияния.
11.5. Непростые вопросы и ответы.
11.5.1. Насколько юнит-тестирование удлинит текущий процесс?.
11.5.2. Не будет ли юнит-тестирование угрожать моей работе в отделе QA?.
11.5.3. Есть ли доказательства, что юнит-тестирование действительно помогает?.
11.5.4. Почему отдел QA все еще находит ошибки?.
11.5.5. У нас большой объем кода без тестов: с чего начинать?.
11.5.6. А если мы разрабатываем комбинацию программного и аппаратного обеспечения?.
11.5.7. Как узнать, что в наших тестах нет ошибок?.
11.5.8. Зачем мне нужны тесты, если отладчик показывает, что мой код работает?.
11.5.9. Как насчет TDD?.
Итоги.
Глава 12. Работа с унаследованным кодом.
12.1. С чего начинать добавление тестов?.
12.2. Принятие решения по стратегии выбора.
12.2.1. Плюсы и минусы стратегии «начать с простого».
12.2.2. Плюсы и минусы стратегии «начать со сложного».
12.3. Написание интеграционных тестов перед рефакторингом.
12.3.1. Прочитайте книгу Майкла Физерса об унаследованном коде.
12.3.2. Используйте CodeScene для анализа своего рабочего кода.
Итоги.
Приложения. Манки-патчинг функций и модулей.
П.1. Обязательное предупреждение.
П.2. Манки-патчинг функций и возможные проблемы.
П.2.1. Манки-патчинг функции по схеме Jest.
П.2.2. Шпионы Jest.
П.2.3. spyOn с mockImplementation().
П.3. Игнорирование целого модуля в Jest.
П.4. Моделирование поведения модуля в каждом тесте.
П.4.1. Создание стаба для модуля базовым вызовом require.cache.
П.4.2. Создание стабов для нестандартных данных из модулей в Jest затруднено.
П.4.3. Избегайте ручных моков Jest.
П.4.4. Создание стаба для модуля с Sinon.js.
П.4.5. Создание стаба для модуля с testdouble.

Купить .





Теги: учебник по программированию :: программирование :: Ошеров :: Хориков :: юнит-тест :: стаб :: код :: фреймворк