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

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

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




Основы юнит-тестирования.
Ручные тесты врагу не пожелаешь. Вы пишете свой код, запускаете его в отладчике, нажимаете нужные клавиши в своем приложении, а затем повторяете все это снова, когда напишете новый код. А еще нужно не забыть проверить весь остальной код, на который мог повлиять новый. Еще больше ручной работы. Замечательно.

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

ОГЛАВЛЕНИЕ.
Отзывы о втором издании.
Предисловие ко второму изданию.
Предисловие к первому изданию.
Введение.
Благодарности.
О книге.
Что нового в третьем издании.
Для кого эта книга.
Структура книги.
О коде в книге.
Программные требования.
Форум 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.



Бесплатно скачать электронную книгу в удобном формате, смотреть и читать:
Скачать книгу Искусство юнит-тестирования с примерами на JavaScript, Ошеров Р., Хориков В., 2025 - fileskachat.com, быстрое и бесплатное скачивание.

Скачать файл № 1 - pdf
Скачать файл № 2 - djvu
Ниже можно купить эту книгу, если она есть в продаже, и похожие книги по лучшей цене со скидкой с доставкой по всей России.Купить книги


Скачать - djvu - Яндекс.Диск.

Скачать - pdf - Яндекс.Диск.




Теги: учебник по программированию :: программирование :: Ошеров :: Хориков