🔗 Интеграционное тестирование: проверка связей между модулями

🧠 Что такое интеграционное тестирование?

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

🔍 Зачем оно нужно?

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

🛠️ Инструменты для интеграционного тестирования

• Python: pytest, unittest, requests
• JavaScript: Mocha, Chai, Jest
• Java: JUnit, TestNG

🧪 Пример 1: Взаимодействие между слоями приложения (новичок)

Предположим, у нас есть два модуля: database.py и user_service.py. Мы хотим проверить, что user_service корректно взаимодействует с базой данных.

# database.py
def get_user_by_id(user_id):
# Здесь обычно запрос к базе данных
return {"id": user_id, "name": "John Doe"}

# user_service.py
from database import get_user_by_id

def get_user_info(user_id):
user = get_user_by_id(user_id)
return f"User: {user['name']}, ID: {user['id']}"

Интеграционный тест:

# test_integration.py
from user_service import get_user_info

def test_get_user_info():
result = get_user_info(1)
assert result == "User: John Doe, ID: 1"

Здесь мы проверяем, что user_service корректно получает данные из database и возвращает ожидаемый результат.

🧪 Пример 2: Взаимодействие с внешним API (мидл)

Предположим, наш сервис отправляет запросы к внешнему API для получения информации о погоде.

# weather_service.py
import requests

def get_weather(city):
response = requests.get(f"http://api.weather.com/{city}")
return response.json()

Интеграционный тест с использованием мока:

# test_weather_service.py
from unittest.mock import patch
from weather_service import get_weather

@patch('weather_service.requests.get')
def test_get_weather(mock_get):
mock_get.return_value.json.return_value = {"temperature": 22}
result = get_weather("Cancun")
assert result["temperature"] == 22

Здесь мы мокаем внешний запрос, чтобы не зависеть от реального API, но проверяем, что наш сервис правильно обрабатывает ответ.

🧪 Пример 3: Взаимодействие между микросервисами (сеньор)

Предположим, у нас есть два микросервиса: order_service и payment_service. Мы хотим проверить, что при создании заказа, автоматически инициируется процесс оплаты.

# order_service.py
import requests

def create_order(order_data):
response = requests.post("http://payment_service/pay", json=order_data)
return response.status_code

Интеграционный тест:

# test_order_service.py
import requests
from unittest.mock import patch
from order_service import create_order

@patch('order_service.requests.post')
def test_create_order(mock_post):
mock_post.return_value.status_code = 200
order_data = {"product_id": 1, "quantity": 2}
result = create_order(order_data)
assert result == 200

Здесь мы проверяем, что при создании заказа, сервис отправляет запрос к payment_service и получает успешный ответ.

🧪 Пример 4: Взаимодействие с базой данных (мидл)

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

# user_repository.py
import sqlite3

def save_user(user):
conn = sqlite3.connect('test.db')
cursor = conn.cursor()
cursor.execute("INSERT INTO users (name) VALUES (?)", (user['name'],))
conn.commit()
conn.close()

Интеграционный тест:

# test_user_repository.py
import sqlite3
from user_repository import save_user

def test_save_user():
user = {"name": "Alice"}
save_user(user)
conn = sqlite3.connect('test.db')
cursor = conn.cursor()
cursor.execute("SELECT * FROM users WHERE name=?", (user['name'],))
result = cursor.fetchone()
conn.close()
assert result is not None

Здесь мы проверяем, что данные пользователя корректно сохраняются в базе данных.

🧪 Пример 5: Взаимодействие между слоями приложения с использованием мока (профессионал)

Предположим, у нас есть сервис, который отправляет уведомления пользователям.

# notification_service.py
from email_service import send_email

def notify_user(user, message):
send_email(user['email'], message)

Интеграционный тест с использованием мока:

# test_notification_service.py
from unittest.mock import patch
from notification_service import notify_user

@patch('notification_service.send_email')
def test_notify_user(mock_send_email):
user = {"email": "test@example.com"}
message = "Hello!"
notify_user(user, message)
mock_send_email.assert_called_with(user['email'], message)

Здесь мы проверяем, что сервис корректно вызывает функцию отправки email.

🧩 Задачи для практики

1. Новичок: Написать интеграционный тест для функции, которая сохраняет данные в файл.
2. Мидл: Написать интеграционный тест для функции, которая взаимодействует с внешним API.
3. Сеньор: Написать интеграционный тест для микросервиса, который взаимодействует с несколькими другими сервисами.
4. Профессионал: Написать интеграционный тест для функции, которая обрабатывает данные из базы данных и отправляет уведомления пользователю.
5. Эксперт: Написать интеграционный тест для сложной бизнес-логики, которая включает взаимодействие с несколькими модулями и внешними сервисами
   

Конечно! Ниже — 🧩 интеграционные задачи для практики с подробными решениями, кодом и комментариями к каждой строчке. Всё от уровня новичка до эксперта. Погнали!

🧩 Новичок: Интеграционный тест — сохранение данных в файл

🔧 Функция:

# file_writer.py
def save_to_file(filename, data):
with open(filename, "w") as f:
f.write(data)

🔬 Интеграционный тест:

# test_file_writer.py
import os
from file_writer import save_to_file

def test_save_to_file():
test_filename = "test_output.txt"
test_data = "Hello, integration!"

save_to_file(test_filename, test_data)

with open(test_filename, "r") as f:
content = f.read()

assert content == test_data

os.remove(test_filename) # Убираем за собой

🧠 Комментарии:

• Пишем файл, читаем обратно — проверяем, что запись сработала.
• Не забываем чистить после себя.

🧩 Мидл: Интеграционный тест — вызов внешнего API

🔧 Функция:

# cat_facts.py
import requests

def get_cat_fact():
r = requests.get("https://catfact.ninja/fact")
return r.json()["fact"]

🔬 Интеграционный тест (c requests-mock):

# test_cat_facts.py
import requests
import requests_mock
from cat_facts import get_cat_fact

def test_get_cat_fact():
with requests_mock.Mocker() as m:
m.get("https://catfact.ninja/fact", json={"fact": "Cats are awesome."})
fact = get_cat_fact()
assert fact == "Cats are awesome."

🧠 Комментарии:

• requests_mock даёт стабильность — внешний API может упасть, а тесты должны быть предсказуемыми.

🧩 Сеньор: Интеграционный тест — микросервис вызывает другие сервисы

🔧 Сервис:

# order_service.py
import requests

def create_order(order_data):
response = requests.post("http://payment-service/pay", json=order_data)
if response.status_code != 200:
raise Exception("Payment failed")
return {"status": "created", "payment": response.json()}

🔬 Интеграционный тест:

# test_order_service.py
from unittest.mock import patch
from order_service import create_order

@patch("order_service.requests.post")
def test_create_order_success(mock_post):
mock_post.return_value.status_code = 200
mock_post.return_value.json.return_value = {"payment_id": "abc123"}

data = {"item": "coffee", "price": 100}
result = create_order(data)

assert result["status"] == "created"
assert result["payment"]["payment_id"] == "abc123"

🧠 Комментарии:

• Мокаем вызов payment-service, но тестируем весь процесс создания заказа как единое целое.

🧩 Профессионал: Интеграционный тест — БД + уведомление

🔧 Модули:

# user_repo.py
import sqlite3

def get_user_email(user_id):
conn = sqlite3.connect("test.db")
cur = conn.cursor()
cur.execute("SELECT email FROM users WHERE id = ?", (user_id,))
result = cur.fetchone()
conn.close()
return result[0] if result else None

# notifier.py
from user_repo import get_user_email

def send_notification(user_id, sender):
email = get_user_email(user_id)
if email:
sender.send(email, "Welcome!")
return True
return False

🔬 Интеграционный тест:

# test_notifier.py
import sqlite3
from notifier import send_notification
from unittest.mock import Mock

def setup_test_db():
conn = sqlite3.connect("test.db")
cur = conn.cursor()
cur.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER, email TEXT)")
cur.execute("DELETE FROM users")
cur.execute("INSERT INTO users VALUES (1, 'test@example.com')")
conn.commit()
conn.close()

def test_send_notification():
setup_test_db()
fake_sender = Mock()

result = send_notification(1, fake_sender)

fake_sender.send.assert_called_with("test@example.com", "Welcome!")
assert result is True

🧠 Комментарии:

• Это уже полноценный интеграционный пайплайн: БД + логика + отправка.
• Используем мок для отправки писем, но реальную БД (sqlite, чтобы просто).

🧩 Эксперт: Интеграционный тест сложной бизнес-логики

📘 Сценарий:

• Клиент оформляет подписку
• Проверяется платёж
• Сохраняется в БД
• Отправляется email

🔧 Код:

# subscription.py
from payment_service import charge_card
from user_repo import save_subscription
from mailer import send_email

def process_subscription(user, card_info):
if not charge_card(card_info):
raise Exception("Payment failed")

save_subscription(user["id"])
send_email(user["email"], "Subscription activated!")
return True

🔬 Интеграционный тест:

# test_subscription.py
from subscription import process_subscription
from unittest.mock import patch

@patch("subscription.send_email")
@patch("subscription.save_subscription")
@patch("subscription.charge_card")
def test_process_subscription(mock_charge, mock_save, mock_send):
mock_charge.return_value = True

user = {"id": 1, "email": "user@example.com"}
card = {"number": "4111 1111 1111 1111"}

result = process_subscription(user, card)

mock_charge.assert_called_once_with(card)
mock_save.assert_called_once_with(user["id"])
mock_send.assert_called_once_with(user["email"], "Subscription activated!")
assert result is True

🧠 Комментарии:

• Сложный тест проверяет весь поток бизнес-логики
• Все сторонние модули (платёж, БД, письма) — мокнуты
• Тест даёт уверенность: если один кусок отвалится — увидим сразу