Моки, патчи и тестовые двойники

from unittest.mock import Mock

m = Mock()
print(m.anything, m.any_method(1, x=2))        # любые атрибуты и вызовы — тоже моки
m.get_rate.return_value = 90.5                  # stub: что вернуть
print(m.get_rate("USD"))

m.get_rate.assert_called_once_with("USD")       # проверить вызов
print(m.get_rate.call_count, m.get_rate.call_args)
print(m.method_calls)

try:
    m.get_rate.assert_called_with("EUR")
except AssertionError as e:
    print("AssertionError:", str(e).splitlines()[0])

from unittest.mock import Mock

api = Mock()
api.fetch.side_effect = TimeoutError("сервер не ответил")       # бросить исключение
try:
    api.fetch()
except TimeoutError as e:
    print("поймали:", e)

api.fetch.side_effect = [1, 2, ValueError("кончились")]         # последовательность ответов
print(api.fetch(), api.fetch())

api.double.side_effect = lambda x: x * 2                        # вычислять ответ функцией
print(api.double(21))

from unittest.mock import MagicMock

f = MagicMock()
f.__enter__.return_value.read.return_value = "содержимое"
with f as handle:
    print(handle.read())
f.__iter__.return_value = iter([1, 2])
print(list(f), len(f))

import sys, types
from unittest.mock import patch

# имитируем два модуля проекта
weather = types.ModuleType("weather")
def get_temperature(city):
    raise RuntimeError("реальный HTTP-запрос — в тестах нельзя")
weather.get_temperature = get_temperature
sys.modules["weather"] = weather

advice = types.ModuleType("advice")
exec("from weather import get_temperature\n"
     "def what_to_wear(city):\n"
     "    t = get_temperature(city)\n"
     "    return 'куртка' if t < 10 else 'футболка'\n", advice.__dict__)
sys.modules["advice"] = advice

from advice import what_to_wear

with patch("weather.get_temperature", return_value=-5):     # ✗ не то место
    try:
        print(what_to_wear("Москва"))
    except RuntimeError as e:
        print("не сработало:", e)

with patch("advice.get_temperature", return_value=-5) as fake:   # ✓ там, где используется
    print(what_to_wear("Москва"))
    fake.assert_called_once_with("Москва")
print("после with оригинал возвращён:", advice.get_temperature is get_temperature)

from unittest.mock import Mock, create_autospec

class EmailSender:
    def send(self, to: str, text: str) -> None: ...

loose = Mock()
loose.sned("a@x.ru", "привет")                  # опечатка в имени метода — и тишина!
loose.send("a@x.ru")                            # забыли аргумент — тоже тишина
print("обычный Mock ничего не заметил:", loose.method_calls)

strict = create_autospec(EmailSender, instance=True)
try:
    strict.sned("a@x.ru", "привет")
except AttributeError as e:
    print("AttributeError:", e)
try:
    strict.send("только один аргумент")
except TypeError as e:
    print("TypeError:", e)

from datetime import datetime
from unittest.mock import patch
import random

def greeting(now=None):                           # 1. лучший способ — передать зависимость
    now = now or datetime.now()
    return "Доброе утро" if now.hour < 12 else "Добрый день"

print(greeting(datetime(2026, 1, 1, 9)), "|", greeting(datetime(2026, 1, 1, 15)))

def roll():
    return random.randint(1, 6)

with patch("random.randint", return_value=6):     # 2. или патч
    print(roll())

random.seed(1)                                    # 3. или фиксированный seed
print([random.randint(1, 6) for _ in range(5)])

class FakeSender:                                # fake: проще и надёжнее мока
    def __init__(self):
        self.sent = []
    def send(self, to, text):
        self.sent.append((to, text))

class Registration:
    def __init__(self, sender):                  # зависимость приходит снаружи
        self.sender = sender
    def register(self, email):
        self.sender.send(email, "Добро пожаловать!")
        return {"email": email}

sender = FakeSender()
Registration(sender).register("anna@x.ru")
assert sender.sent == [("anna@x.ru", "Добро пожаловать!")]
print(sender.sent)