Интеграционное тестирование: как проверить, что модули работают вместе

Интеграционное тестирование

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

Сегодня мы разберём интеграционное тестирование — проверку того, как модули взаимодействуют друг с другом.

🔗 Интеграция 🧩 Модули 🚗 Драйверы 🎭 Заглушки

                     Это шестая лекция из цикла. Она посвящена следующему уровню тестирования после модульного. Без неё невозможно представить тестирование реальных проектов.
                

Формат: лекция + практика в конце. В следующей лекции — формальные инспекции и верификация.

План лекции

Сегодня мы разберём, как проверять взаимодействие модулей.

1 Зачем нужно интеграционное тестирование
2 Что такое интеграция
3 Виды интеграционного тестирования
4 Восходящее тестирование
5 Нисходящее тестирование
6 Монолитное тестирование
7 Драйверы и заглушки
8 Пример: интеграция калькулятора
9 Типичные ошибки при интеграции
10 Итоги и практика

Если вы пропустили предыдущие лекции — вернитесь. Без понимания модульного тестирования интеграционное будет непонятно.

Зачем нужно интеграционное тестирование

Представьте, что у вас есть три модуля: сложение, вычитание и вывод на экран. Каждый по отдельности работает идеально.

Аналогия. Представьте, что у вас есть три детали конструктора. Каждая идеальна. Но если их неправильно соединить — самолёт не полетит. Интеграционное тестирование проверяет, что детали соединяются правильно.

// Модуль 1: сложение def add(a, b): return a + b // Модуль 2: вывод на экран def print_result(value): print("Результат:", value) // Интеграция: если между ними неправильно передаётся число — // пользователь увидит неправильный результат.

Интеграционное тестирование ищет ошибки в «стыках» — там, где один модуль передаёт данные другому.

Что такое интеграция

Интеграция (integration) — это объединение отдельных модулей в единое целое.

Модуль A

+

Модуль B

+

Модуль C

→

Система

УровеньЧто проверяет Модульноеодну функцию Интеграционноевзаимодействие нескольких модулей Системноевсю систему целиком

Интеграционное тестирование — это «мостик» между модульным и системным тестированием. Оно проверяет, что модули могут работать вместе.

Виды интеграционного тестирования

Есть несколько стратегий интеграции. Каждая определяет, в каком порядке соединять модули.

⬆️

Восходящее
Сначала нижние модули, потом верхние.

⬇️

Нисходящее
Сначала верхние модули, потом нижние.

🧱

Монолитное
Все модули сразу, потом тестирование.

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

Восходящее тестирование

Восходящее тестирование (bottom-up) — сначала тестируются нижние модули (те, которые не зависят от других), потом — верхние.

Модуль C (верхний)

↑

Модуль B (средний)

↑

Модуль A (нижний)

ПлюсыМинусы Легко локализовать ошибкиНужны драйверы для вызова нижних модулей Нижние модули уже протестированыВерхние модули тестируются поздно

Восходящее тестирование — это «снизу вверх». Сначала фундамент, потом стены, потом крыша.

Нисходящее тестирование

Нисходящее тестирование (top-down) — сначала тестируются верхние модули, потом — нижние.

Модуль C (верхний)

↓

Модуль B (средний)

↓

Модуль A (нижний)

ПлюсыМинусы Верхние модули тестируются раноНужны заглушки для нижних модулей Легко увидеть общую картинуНижние модули тестируются поздно

Нисходящее тестирование — это «сверху вниз». Сначала крыша, потом стены, потом фундамент.

Монолитное тестирование

Монолитное тестирование (big bang) — все модули соединяются сразу, и система тестируется целиком.

Модуль A

+

Модуль B

+

Модуль C

→

Тестирование

ПлюсыМинусы Не нужны драйверы и заглушкиТрудно найти причину ошибки Быстро (если модулей мало)Ошибки могут «маскировать» друг друга

Монолитное тестирование подходит для маленьких проектов. В больших — слишком сложно найти причину ошибки.

Монолитное тестирование не заменяет модульное и интеграционное. Оно дополняет их.

Драйверы и заглушки

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

🚗

Драйвер (driver)
Вызывает тестируемый модуль. Имитирует «верхний» модуль, который ещё не готов.

🎭

Заглушка (stub)
Имитирует «нижний» модуль, который ещё не готов. Возвращает заранее заданные значения.

// Пример заглушки на Python def stub_add(a, b): # Всегда возвращает 0, чтобы проверить, как модуль реагирует return 0 // Пример драйвера def driver(): result = add(3, 5) print("Результат:", result)

Драйвер — это «руки», которые вызывают тестируемый модуль. Заглушка — это «подставной» модуль, который возвращает заранее известные данные.

Пример: интеграция калькулятора

У нас есть два модуля: add (сложение) и print_result (вывод). Проверим, как они работают вместе.

# Модуль 1: calc.py def add(a, b): return a + b # Модуль 2: printer.py def print_result(value): return f"Результат: {value}" # Интеграция: main.py from calc import add from printer import print_result def calculate_and_print(a, b): result = add(a, b) return print_result(result)

Тест интеграции

def test_integration(): assert calculate_and_print(3, 5) == "Результат: 8"

Если тест проходит — модули работают вместе правильно. Если нет — ошибка на «стыке».

Типичные ошибки при интеграции

1. Несовпадение типов
Один модуль возвращает строку, другой ожидает число.

2. Несовпадение форматов
Один модуль возвращает дату в формате YYYY-MM-DD, другой ожидает DD.MM.YYYY.

3. Неправильный порядок вызовов
Модуль B вызывается до того, как модуль A подготовил данные.

4. Потеря данных
Один модуль передаёт данные, другой их не получает.

5. Ошибки в контрактах
Один модуль обещает вернуть число, а возвращает null.

6. Необработанные исключения
Один модуль выбрасывает исключение, другой его не ловит.

Как избежать ошибок интеграции

Есть несколько практик, которые помогают снизить количество ошибок на «стыках».

Чёткие контракты. Каждый модуль должен явно описывать, что он принимает и что возвращает.
Проверка типов. Используйте типизацию (Python type hints, C++ типы).
Ранняя интеграция. Не откладывайте соединение модулей «на потом».
Автотесты. Пишите тесты, которые проверяют взаимодействие модулей.
Логирование. Записывайте, какие данные передаются между модулями.

Хороший контракт между модулями — это половина успеха интеграции. Если модули «договариваются» о формате данных заранее, ошибок будет меньше.

Практическое задание

Примените полученные знания на практике.

Задание 1

Напишите два модуля: multiply(a, b) и format_result(value). Напишите тест, который проверяет их совместную работу.

Задание 2

Придумайте три ошибки, которые могут возникнуть при интеграции этих модулей (несовпадение типов, форматов, порядка вызовов).

Задание 3

Объясните своими словами, чем драйвер отличается от заглушки.

Решения разберём на практическом занятии. Не бойтесь ошибаться — интеграционное тестирование сложнее модульного, но и полезнее.

Шпаргалка

Сохраните этот слайд — здесь все основные понятия лекции.

ТерминЧто значит Интеграцияобъединение модулей в систему Восходящее тестированиеснизу вверх Нисходящее тестированиесверху вниз Монолитное тестированиевсе модули сразу Драйвервызывает тестируемый модуль Заглушкаимитирует другой модуль

Итоги лекции

Подведём итоги. Вот что вы теперь знаете.

✅ Интеграционное тестирование проверяет, как модули работают вместе.
✅ Восходящее — снизу вверх, нисходящее — сверху вниз, монолитное — все сразу.
✅ Драйвер вызывает модуль, заглушка имитирует другой модуль.
✅ Ошибки интеграции часто связаны с типами, форматами и порядком вызовов.
✅ Чёткие контракты и автотесты помогают избежать проблем.

В следующей лекции мы разберём формальные инспекции — метод проверки кода и документации без запуска программы. Это ещё один способ найти ошибки.

Домашнее задание

Задания для самостоятельной работы. Первые два обязательны, остальные — для оценки «отлично».

Напишите два модуля (например, multiply и format_result) и тест их совместной работы.
Объясните своими словами, чем восходящее тестирование отличается от нисходящего.
Придумайте три ошибки, которые могут возникнуть при интеграции модулей.
Найдите в интернете пример реальной ошибки интеграции и объясните, как её нашли.
Напишите заглушку для функции, которая возвращает случайное число. Объясните, зачем она нужна.

Если задание кажется сложным — разбейте его на части. Сначала один модуль, потом второй, потом тест.

Что дальше?

В этом блоке по тестированию у нас ещё несколько материалов.

Лекция 7: формальные инспекции и верификация.
Практика 3: интеграционное тестирование на Python.
Лекция 8: тестирование в MSF и роли в команде.

Интеграционное тестирование — это шаг от «отдельных функций» к «работающей системе». Без него невозможно представить тестирование реальных проектов.

Спасибо за внимание!

🔗

Модули по отдельности — это ещё не система

Только когда они работают вместе, программа становится полезной. Интеграционное тестирование проверяет именно это.

🔗 Интеграция 🚗 Драйверы 🎭 Заглушки 🚀 практика