"""Интеграционные проверки обработки вебхуков PaymentService.""" from __future__ import annotations from __future__ import annotations from pathlib import Path from types import SimpleNamespace, ModuleType from typing import Any, Dict, Optional import sys import pytest from unittest.mock import AsyncMock ROOT_DIR = Path(__file__).resolve().parents[2] if str(ROOT_DIR) not in sys.path: sys.path.insert(0, str(ROOT_DIR)) import app.services.payment_service as payment_service_module # noqa: E402 import app.services.payment.cryptobot as cryptobot_module # noqa: E402 from app.services.payment_service import PaymentService # noqa: E402 from app.database.models import PaymentMethod # noqa: E402 from app.config import settings # noqa: E402 class DummyBot: def __init__(self) -> None: self.sent_messages: list[Dict[str, Any]] = [] async def send_message(self, *args: Any, **kwargs: Any) -> None: # pragma: no cover - бизнес-логика тестируется через вызов self.sent_messages.append({"args": args, "kwargs": kwargs}) class FakeScalarResult: def __init__(self, items: list[Any]) -> None: self._items = list(items) def all(self) -> list[Any]: # pragma: no cover - утилитарный метод return list(self._items) def first(self) -> Any: # pragma: no cover - утилитарный метод return self._items[0] if self._items else None def one(self) -> Any: # pragma: no cover - утилитарный метод if len(self._items) != 1: raise ValueError("Expected exactly one result") return self._items[0] def one_or_none(self) -> Any: # pragma: no cover - утилитарный метод if not self._items: return None if len(self._items) > 1: raise ValueError("Expected zero or one result") return self._items[0] def __iter__(self): # pragma: no cover - утилитарный метод return iter(self._items) class FakeResult: def __init__(self, value: Any = None) -> None: self._value = value def _as_iterable(self) -> list[Any]: if isinstance(self._value, list): return self._value if self._value is None: return [] return [self._value] def scalar(self) -> Any: items = self._as_iterable() return items[0] if items else None def scalar_one_or_none(self) -> Any: items = self._as_iterable() if not items: return None if len(items) > 1: raise ValueError("Expected zero or one result") return items[0] def first(self) -> Any: # pragma: no cover - утилитарный метод items = self._as_iterable() return items[0] if items else None def all(self) -> list[Any]: # pragma: no cover - утилитарный метод return list(self._as_iterable()) def one_or_none(self) -> Any: # pragma: no cover - утилитарный метод items = self._as_iterable() if not items: return None if len(items) > 1: raise ValueError("Expected zero or one result") return items[0] def scalars(self) -> FakeScalarResult: # pragma: no cover - утилитарный метод return FakeScalarResult(self._as_iterable()) class FakeSession: def __init__(self) -> None: self.commits = 0 self.refreshed: list[Any] = [] self.added: list[Any] = [] self.execute_statements: list[Any] = [] self.execute_results: list[Any] = [] async def commit(self) -> None: self.commits += 1 async def rollback(self) -> None: # pragma: no cover return None async def refresh(self, obj: Any) -> None: self.refreshed.append(obj) def add(self, obj: Any) -> None: # pragma: no cover - используется при создании транзакций self.added.append(obj) async def execute(self, statement: Any, *args: Any, **kwargs: Any) -> FakeResult: self.execute_statements.append(statement) if self.execute_results: result = self.execute_results.pop(0) if callable(result): # pragma: no cover - гибкость для будущих тестов result = result(statement, *args, **kwargs) else: result = None if isinstance(result, FakeResult): return result return FakeResult(result) def _make_service(bot: DummyBot) -> PaymentService: service = PaymentService.__new__(PaymentService) # type: ignore[call-arg] service.bot = bot service.yookassa_service = None service.stars_service = None service.mulenpay_service = None service.pal24_service = None service.cryptobot_service = None service.heleket_service = None return service @pytest.fixture def anyio_backend() -> str: return "asyncio" @pytest.mark.anyio("asyncio") @pytest.mark.parametrize("status_field", ["payment_status", "status", "paymentStatus"]) async def test_process_mulenpay_callback_success( monkeypatch: pytest.MonkeyPatch, status_field: str ) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() payment = SimpleNamespace( uuid="mulen_uuid", mulen_payment_id=123, amount_kopeks=5000, user_id=42, transaction_id=None, is_paid=False, ) async def fake_get_by_uuid(db, uuid): return payment async def fake_get_by_id(db, mid): return None monkeypatch.setattr(payment_service_module, "get_mulenpay_payment_by_uuid", fake_get_by_uuid) monkeypatch.setattr(payment_service_module, "get_mulenpay_payment_by_mulen_id", fake_get_by_id) transactions: list[Dict[str, Any]] = [] async def fake_create_transaction(db, **kwargs): transactions.append(kwargs) return SimpleNamespace(id=777, **kwargs) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) updated_status: dict[str, Any] = {} async def fake_update_status(db, payment=None, status=None, **kwargs): payment.status = status payment.is_paid = status == "success" updated_status.update({"status": status, "kwargs": kwargs}) monkeypatch.setattr(payment_service_module, "update_mulenpay_payment_status", fake_update_status) async def fake_link(db, payment=None, transaction_id=None): payment.transaction_id = transaction_id monkeypatch.setattr(payment_service_module, "link_mulenpay_payment_to_transaction", fake_link) user = SimpleNamespace( id=42, telegram_id=100500, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_mock = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_mock) class DummyAdminService: def __init__(self, bot): self.bot = bot self.calls: list[Any] = [] async def send_balance_topup_notification(self, *args, **kwargs): self.calls.append((args, kwargs)) admin_service = DummyAdminService(bot) monkeypatch.setitem(sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: admin_service)) service.build_topup_success_keyboard = AsyncMock(return_value=None) payload = { "uuid": "mulen_uuid", "id": 123, "amount": "50.00", } payload[status_field] = "success" result = await service.process_mulenpay_callback(fake_session, payload) assert result is True assert transactions and transactions[0]["user_id"] == 42 assert payment.transaction_id == 777 assert updated_status["status"] == "success" assert user.balance_kopeks == 5000 assert fake_session.commits >= 1 assert bot.sent_messages # сообщение пользователю отправлено @pytest.mark.anyio("asyncio") async def test_process_cryptobot_webhook_success(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() payment = SimpleNamespace( invoice_id="inv_1", user_id=7, status="pending", transaction_id=None, amount="12.50", asset="USDT", amount_float=12.5, ) async def fake_get_crypto(db, invoice_id): return payment async def fake_update_status(db, invoice_id, status, paid_at): payment.status = status payment.paid_at = paid_at return payment async def fake_link(db, invoice_id, transaction_id): payment.transaction_id = transaction_id fake_cryptobot_module = ModuleType("app.database.crud.cryptobot") fake_cryptobot_module.get_cryptobot_payment_by_invoice_id = fake_get_crypto fake_cryptobot_module.update_cryptobot_payment_status = fake_update_status fake_cryptobot_module.link_cryptobot_payment_to_transaction = fake_link monkeypatch.setitem(sys.modules, "app.database.crud.cryptobot", fake_cryptobot_module) transactions: list[Dict[str, Any]] = [] created_transaction: SimpleNamespace | None = None async def fake_create_transaction(db, **kwargs): nonlocal created_transaction transactions.append(kwargs) created_transaction = SimpleNamespace(id=888, **kwargs) return created_transaction fake_transaction_module = ModuleType("app.database.crud.transaction") fake_transaction_module.create_transaction = fake_create_transaction async def fake_get_transaction_by_id(db, transaction_id): return created_transaction fake_transaction_module.get_transaction_by_id = fake_get_transaction_by_id monkeypatch.setitem(sys.modules, "app.database.crud.transaction", fake_transaction_module) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=7, telegram_id=700, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user_crypto(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user_crypto) fake_user_module = ModuleType("app.database.crud.user") fake_user_module.get_user_by_id = fake_get_user_crypto monkeypatch.setitem(sys.modules, "app.database.crud.user", fake_user_module) referral_crypto = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_crypto) admin_calls: list[Any] = [] class DummyAdminService2: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_calls.append((args, kwargs)) monkeypatch.setitem(sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminService2(bot))) class DummyAsyncSession: async def __aenter__(self): return self async def __aexit__(self, exc_type, exc, tb): return False async def rollback(self): # pragma: no cover - defensive stub return None monkeypatch.setattr(cryptobot_module, "AsyncSessionLocal", lambda: DummyAsyncSession()) monkeypatch.setattr(payment_service_module.currency_converter, "usd_to_rub", AsyncMock(return_value=140.0)) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) service.build_topup_success_keyboard = AsyncMock(return_value=None) payload = { "update_type": "invoice_paid", "payload": { "invoice_id": "inv_1", "paid_at": "2024-01-01T12:00:00Z", }, } result = await service.process_cryptobot_webhook(fake_session, payload) assert result is True assert transactions and transactions[0]["amount_kopeks"] == 14000 assert user.balance_kopeks == 14000 assert payment.transaction_id == 888 assert bot.sent_messages assert admin_calls @pytest.mark.anyio("asyncio") async def test_process_heleket_webhook_success(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() payment = SimpleNamespace( uuid="heleket-uuid", order_id="heleket-order", user_id=77, amount="150.00", amount_float=150.0, amount_kopeks=15000, status="check", payer_amount=None, payer_currency=None, exchange_rate=None, discount_percent=None, payment_url=None, transaction_id=None, ) async def fake_get_by_uuid(db, uuid): return payment if uuid == payment.uuid else None async def fake_get_by_order(db, order_id): return payment if order_id == payment.order_id else None async def fake_update( db, uuid, *, status=None, payer_amount=None, payer_currency=None, exchange_rate=None, discount_percent=None, paid_at=None, payment_url=None, metadata=None, ): if status is not None: payment.status = status if payer_amount is not None: payment.payer_amount = payer_amount if payer_currency is not None: payment.payer_currency = payer_currency if exchange_rate is not None: payment.exchange_rate = exchange_rate if discount_percent is not None: payment.discount_percent = discount_percent if payment_url is not None: payment.payment_url = payment_url payment.paid_at = paid_at if metadata: payment.metadata_json = metadata return payment async def fake_link(db, uuid, transaction_id): payment.transaction_id = transaction_id return payment heleket_module = ModuleType("app.database.crud.heleket") heleket_module.get_heleket_payment_by_uuid = fake_get_by_uuid heleket_module.get_heleket_payment_by_order_id = fake_get_by_order heleket_module.update_heleket_payment = fake_update heleket_module.link_heleket_payment_to_transaction = fake_link monkeypatch.setitem(sys.modules, "app.database.crud.heleket", heleket_module) transactions: list[Dict[str, Any]] = [] async def fake_create_transaction(db, **kwargs): transactions.append(kwargs) return SimpleNamespace(id=321, **kwargs) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=77, telegram_id=7700, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, language="ru", ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user(db, user_id): return user if user_id == user.id else None monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr("app.services.payment.heleket.format_referrer_info", lambda u: "") monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_stub = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_stub) admin_calls: list[Any] = [] class DummyAdminService: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_calls.append((args, kwargs)) monkeypatch.setitem( sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminService(bot)), ) service.build_topup_success_keyboard = AsyncMock(return_value=None) payload = { "uuid": "heleket-uuid", "status": "paid", "payer_amount": "2.50", "payer_currency": "USDT", "discount_percent": -5, "payer_amount_exchange_rate": "0.0166", "paid_at": "2024-01-02T12:00:00Z", "url": "https://pay.example", } result = await service.process_heleket_webhook(fake_session, payload) assert result is True assert transactions and transactions[0]["payment_method"] == PaymentMethod.HELEKET assert payment.transaction_id == 321 assert user.balance_kopeks == 15000 assert user.has_made_first_topup is True assert fake_session.commits >= 1 assert bot.sent_messages assert admin_calls referral_stub.process_referral_topup.assert_awaited_once() @pytest.mark.anyio("asyncio") async def test_process_yookassa_webhook_success(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() payment = SimpleNamespace( yookassa_payment_id="yk_123", user_id=21, amount_kopeks=10000, transaction_id=None, status="pending", is_paid=False, ) async def fake_get_payment(db, payment_id): return payment async def fake_update(db, payment_id, status, is_paid, is_captured, captured_at, payment_method_type): payment.status = status payment.is_paid = is_paid payment.captured_at = captured_at return payment async def fake_link(db, payment_id, transaction_id): payment.transaction_id = transaction_id yk_module = ModuleType("app.database.crud.yookassa") yk_module.get_yookassa_payment_by_id = fake_get_payment yk_module.update_yookassa_payment_status = fake_update yk_module.link_yookassa_payment_to_transaction = fake_link monkeypatch.setitem(sys.modules, "app.database.crud.yookassa", yk_module) transactions: list[Dict[str, Any]] = [] async def fake_create_transaction(db, **kwargs): transactions.append(kwargs) return SimpleNamespace(id=999, **kwargs) trx_module = ModuleType("app.database.crud.transaction") trx_module.create_transaction = fake_create_transaction monkeypatch.setitem(sys.modules, "app.database.crud.transaction", trx_module) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=21, telegram_id=2100, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_mock = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_mock) admin_calls: list[Any] = [] class DummyAdminService: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_calls.append((args, kwargs)) monkeypatch.setitem(sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminService(bot))) service.build_topup_success_keyboard = AsyncMock(return_value=None) payload = { "object": { "id": "yk_123", "status": "succeeded", "paid": True, "payment_method": {"type": "bank_card"}, } } result = await service.process_yookassa_webhook(fake_session, payload) assert result is True assert transactions and transactions[0]["amount_kopeks"] == 10000 assert payment.transaction_id == 999 assert payment.is_paid is True assert user.balance_kopeks == 10000 assert bot.sent_messages assert admin_calls @pytest.mark.anyio("asyncio") async def test_process_yookassa_webhook_uses_remote_status(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() payment = SimpleNamespace( yookassa_payment_id="yk_789", user_id=42, amount_kopeks=20000, transaction_id=None, status="pending", is_paid=False, ) async def fake_get_payment(db, payment_id): return payment async def fake_update(db, payment_id, status, is_paid, is_captured, captured_at, payment_method_type): payment.status = status payment.is_paid = is_paid payment.captured_at = captured_at payment.payment_method_type = payment_method_type return payment async def fake_link(db, payment_id, transaction_id): payment.transaction_id = transaction_id yk_module = ModuleType("app.database.crud.yookassa") yk_module.get_yookassa_payment_by_id = fake_get_payment yk_module.update_yookassa_payment_status = fake_update yk_module.link_yookassa_payment_to_transaction = fake_link monkeypatch.setitem(sys.modules, "app.database.crud.yookassa", yk_module) transactions: list[Dict[str, Any]] = [] async def fake_create_transaction(db, **kwargs): transactions.append(kwargs) return SimpleNamespace(id=555, **kwargs) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=42, telegram_id=4200, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, ) async def fake_get_user(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_mock = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_mock) admin_calls: list[Any] = [] class DummyAdminService: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_calls.append((args, kwargs)) monkeypatch.setitem( sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminService(bot)), ) service.build_topup_success_keyboard = AsyncMock(return_value=None) remote_payload = { "id": "yk_789", "status": "succeeded", "paid": True, "amount_value": 200.0, "amount_currency": "rub", "payment_method_type": "bank_card", "refundable": True, } get_info_mock = AsyncMock(return_value=remote_payload) service.yookassa_service = SimpleNamespace(get_payment_info=get_info_mock) payload = { "object": { "id": "yk_789", "status": "pending", "paid": False, } } result = await service.process_yookassa_webhook(fake_session, payload) assert result is True assert payment.status == "succeeded" assert payment.is_paid is True assert transactions and transactions[0]["amount_kopeks"] == 20000 assert payment.transaction_id == 555 get_info_mock.assert_awaited_once_with("yk_789") assert admin_calls @pytest.mark.anyio("asyncio") async def test_process_yookassa_webhook_handles_cancellation(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() payment = SimpleNamespace( yookassa_payment_id="yk_cancel", user_id=77, amount_kopeks=5000, transaction_id=None, status="pending", is_paid=False, captured_at=None, payment_method_type=None, ) async def fake_get_payment(db, payment_id): return payment monkeypatch.setattr( payment_service_module, "get_yookassa_payment_by_id", fake_get_payment, ) get_info_mock = AsyncMock( return_value={ "id": "yk_cancel", "status": "canceled", "paid": False, "amount_value": 50.0, "amount_currency": "RUB", } ) service.yookassa_service = SimpleNamespace(get_payment_info=get_info_mock) payload = { "object": { "id": "yk_cancel", "status": "pending", "paid": False, } } result = await service.process_yookassa_webhook(fake_session, payload) assert result is True assert payment.status == "canceled" assert payment.is_paid is False assert fake_session.commits == 1 assert fake_session.refreshed and fake_session.refreshed[0] is payment assert bot.sent_messages == [] get_info_mock.assert_awaited_once_with("yk_cancel") @pytest.mark.anyio("asyncio") async def test_process_yookassa_webhook_restores_missing_payment( monkeypatch: pytest.MonkeyPatch, ) -> None: bot = DummyBot() service = _make_service(bot) fake_session = FakeSession() restored_payment = SimpleNamespace( yookassa_payment_id="yk_456", user_id=21, amount_kopeks=0, status="pending", is_paid=False, transaction_id=None, description="", payment_method_type=None, confirmation_url=None, metadata_json=None, test_mode=False, refundable=False, ) get_calls = {"count": 0} async def fake_get_payment(db, payment_id): get_calls["count"] += 1 if get_calls["count"] == 1: return None return restored_payment async def fake_create_payment(**kwargs: Any): restored_payment.user_id = kwargs["user_id"] restored_payment.amount_kopeks = kwargs["amount_kopeks"] restored_payment.status = kwargs["status"] restored_payment.description = kwargs["description"] restored_payment.payment_method_type = kwargs["payment_method_type"] restored_payment.confirmation_url = kwargs["confirmation_url"] restored_payment.metadata_json = kwargs["metadata_json"] restored_payment.test_mode = kwargs["test_mode"] restored_payment.yookassa_payment_id = kwargs["yookassa_payment_id"] restored_payment.yookassa_created_at = kwargs["yookassa_created_at"] return restored_payment async def fake_update_status( db, yookassa_payment_id, status, is_paid, is_captured, captured_at, payment_method_type, ): restored_payment.status = status restored_payment.is_paid = is_paid restored_payment.is_captured = is_captured restored_payment.captured_at = captured_at restored_payment.payment_method_type = payment_method_type return restored_payment async def fake_link(db, yookassa_payment_id, transaction_id): restored_payment.transaction_id = transaction_id monkeypatch.setattr(payment_service_module, "get_yookassa_payment_by_id", fake_get_payment) monkeypatch.setattr(payment_service_module, "create_yookassa_payment", fake_create_payment) monkeypatch.setattr(payment_service_module, "update_yookassa_payment_status", fake_update_status) monkeypatch.setattr(payment_service_module, "link_yookassa_payment_to_transaction", fake_link) transactions: list[Dict[str, Any]] = [] async def fake_create_transaction(db, **kwargs): transactions.append(kwargs) return SimpleNamespace(id=555, **kwargs) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=21, telegram_id=2100, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_mock = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_mock) admin_calls: list[Any] = [] class DummyAdminService: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_calls.append((args, kwargs)) monkeypatch.setitem(sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminService(bot))) service.build_topup_success_keyboard = AsyncMock(return_value=None) payload = { "object": { "id": "yk_456", "status": "succeeded", "paid": True, "amount": {"value": "150.00", "currency": "RUB"}, "metadata": {"user_id": "21", "payment_purpose": "balance_topup"}, "description": "Пополнение", "payment_method": {"type": "bank_card"}, "created_at": "2024-01-02T12:00:00Z", "captured_at": "2024-01-02T12:05:00Z", "confirmation": {"confirmation_url": "https://pay.example"}, } } result = await service.process_yookassa_webhook(fake_session, payload) assert result is True assert get_calls["count"] >= 2 # повторный запрос после восстановления assert restored_payment.amount_kopeks == 15000 assert restored_payment.is_paid is True assert transactions and transactions[0]["amount_kopeks"] == 15000 assert restored_payment.transaction_id == 555 assert user.balance_kopeks == 15000 assert bot.sent_messages assert admin_calls @pytest.mark.anyio("asyncio") async def test_process_yookassa_webhook_missing_metadata(monkeypatch: pytest.MonkeyPatch) -> None: service = _make_service(DummyBot()) db = FakeSession() async def fake_get_payment(db_session, payment_id): return None create_mock = AsyncMock() update_mock = AsyncMock() monkeypatch.setattr(payment_service_module, "get_yookassa_payment_by_id", fake_get_payment) monkeypatch.setattr(payment_service_module, "create_yookassa_payment", create_mock) monkeypatch.setattr(payment_service_module, "update_yookassa_payment_status", update_mock) payload = {"object": {"id": "yk_missing", "status": "succeeded", "paid": True}} result = await service.process_yookassa_webhook(db, payload) assert result is False create_mock.assert_not_awaited() update_mock.assert_not_awaited() @pytest.mark.anyio("asyncio") async def test_process_yookassa_webhook_missing_id(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) db = FakeSession() result = await service.process_yookassa_webhook(db, {"object": {}}) assert result is False @pytest.mark.anyio("asyncio") async def test_process_pal24_callback_success(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) service.pal24_service = SimpleNamespace(is_configured=True) fake_session = FakeSession() payment = SimpleNamespace( bill_id="BILL-1", order_id="order-1", amount_kopeks=5000, user_id=33, transaction_id=None, is_paid=False, status="NEW", metadata_json={}, payment_method=None, paid_at=None, ) async def fake_get_by_order(db, order_id): return payment async def fake_get_by_bill(db, bill_id): return payment async def fake_update(db, payment_obj, **kwargs): payment.status = kwargs.get("status", payment.status) payment.is_paid = kwargs.get("is_paid", payment.is_paid) payment.payment_status = kwargs.get("payment_status", payment.status) payment.callback_payload = kwargs.get("callback_payload") return payment async def fake_link(db, payment_obj, transaction_id): payment.transaction_id = transaction_id pal_module = ModuleType("app.database.crud.pal24") pal_module.get_pal24_payment_by_order_id = fake_get_by_order pal_module.get_pal24_payment_by_bill_id = fake_get_by_bill pal_module.update_pal24_payment_status = fake_update pal_module.link_pal24_payment_to_transaction = fake_link monkeypatch.setitem(sys.modules, "app.database.crud.pal24", pal_module) monkeypatch.setattr(payment_service_module, "get_pal24_payment_by_order_id", fake_get_by_order) monkeypatch.setattr(payment_service_module, "get_pal24_payment_by_bill_id", fake_get_by_bill) monkeypatch.setattr(payment_service_module, "update_pal24_payment_status", fake_update) monkeypatch.setattr(payment_service_module, "link_pal24_payment_to_transaction", fake_link) async def fake_create_transaction(db, **kwargs): payment.transaction_id = 654 return SimpleNamespace(id=654, **kwargs) trx_module = ModuleType("app.database.crud.transaction") trx_module.create_transaction = fake_create_transaction monkeypatch.setitem(sys.modules, "app.database.crud.transaction", trx_module) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=33, telegram_id=3300, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, language="ru", ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_pal = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_pal) admin_calls: list[Any] = [] class DummyAdminServicePal: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_calls.append((args, kwargs)) monkeypatch.setitem( sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminServicePal(bot)), ) user_cart_stub = SimpleNamespace( user_cart_service=SimpleNamespace(has_user_cart=AsyncMock(return_value=True)) ) monkeypatch.setitem(sys.modules, "app.services.user_cart_service", user_cart_stub) class DummyTypes: class InlineKeyboardMarkup: def __init__(self, inline_keyboard=None, **kwargs): self.inline_keyboard = inline_keyboard or [] self.kwargs = kwargs class InlineKeyboardButton: def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs monkeypatch.setitem(sys.modules, "aiogram", SimpleNamespace(types=DummyTypes)) monkeypatch.setitem( sys.modules, "app.localization.texts", SimpleNamespace(get_texts=lambda language: SimpleNamespace(t=lambda key, default=None: default)), ) service.build_topup_success_keyboard = AsyncMock(return_value=None) payload = { "InvId": "order-1", "OutSum": "50.00", "Status": "SUCCESS", "TrsId": "trs-1", } result = await service.process_pal24_callback(fake_session, payload) assert result is True assert payment.transaction_id == 654 assert user.balance_kopeks == 5000 assert bot.sent_messages saved_cart_message = bot.sent_messages[-1] reply_markup = saved_cart_message["kwargs"].get("reply_markup") assert reply_markup is not None assert reply_markup.inline_keyboard[0][0].kwargs["callback_data"] == "return_to_saved_cart" assert admin_calls @pytest.mark.anyio("asyncio") async def test_get_pal24_payment_status_auto_finalize(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) class DummyPal24Service: BILL_SUCCESS_STATES = {"SUCCESS", "OVERPAID"} BILL_FAILED_STATES = {"FAIL"} BILL_PENDING_STATES = {"NEW", "PROCESS", "UNDERPAID"} async def get_bill_status(self, bill_id: str) -> Dict[str, Any]: return { "status": "SUCCESS", "bill": { "status": "SUCCESS", "payments": [ { "id": "trs-auto-1", "status": "SUCCESS", "method": "SBP", "balance_amount": "50.00", "balance_currency": "RUB", } ], }, } async def get_payment_status(self, payment_id: str) -> Optional[Dict[str, Any]]: return None async def get_bill_payments(self, bill_id: str) -> Optional[Dict[str, Any]]: return { "data": [ { "id": "trs-auto-1", "bill_id": bill_id, "status": "SUCCESS", "payment_method": "SBP", } ] } service.pal24_service = DummyPal24Service() fake_session = FakeSession() payment = SimpleNamespace( id=77, bill_id="BILL-AUTO", order_id="order-auto", amount_kopeks=5000, user_id=91, transaction_id=None, is_paid=False, status="NEW", metadata_json={}, payment_id=None, payment_method=None, paid_at=None, ) async def fake_get_payment_by_id(db, local_id): return payment async def fake_update_payment(db, payment_obj, **kwargs): for key, value in kwargs.items(): setattr(payment, key, value) return payment async def fake_link_payment(db, payment_obj, transaction_id): payment.transaction_id = transaction_id return payment monkeypatch.setattr(payment_service_module, "get_pal24_payment_by_id", fake_get_payment_by_id) monkeypatch.setattr(payment_service_module, "update_pal24_payment_status", fake_update_payment) monkeypatch.setattr(payment_service_module, "link_pal24_payment_to_transaction", fake_link_payment) transactions: list[Dict[str, Any]] = [] async def fake_create_transaction(db, **kwargs): transactions.append(kwargs) payment.transaction_id = 999 return SimpleNamespace(id=999, **kwargs) monkeypatch.setattr(payment_service_module, "create_transaction", fake_create_transaction) user = SimpleNamespace( id=91, telegram_id=9100, balance_kopeks=0, has_made_first_topup=False, promo_group=None, subscription=None, referred_by_id=None, referrer=None, language="ru", ) user.get_primary_promo_group = lambda: getattr(user, "promo_group", None) async def fake_get_user(db, user_id): return user monkeypatch.setattr(payment_service_module, "get_user_by_id", fake_get_user) monkeypatch.setattr(type(settings), "format_price", lambda self, amount: f"{amount / 100:.2f}₽", raising=False) referral_stub = SimpleNamespace(process_referral_topup=AsyncMock()) monkeypatch.setitem(sys.modules, "app.services.referral_service", referral_stub) admin_notifications: list[Any] = [] class DummyAdminService: def __init__(self, bot): self.bot = bot async def send_balance_topup_notification(self, *args, **kwargs): admin_notifications.append((args, kwargs)) monkeypatch.setitem( sys.modules, "app.services.admin_notification_service", SimpleNamespace(AdminNotificationService=lambda bot: DummyAdminService(bot)), ) user_cart_stub = SimpleNamespace( user_cart_service=SimpleNamespace(has_user_cart=AsyncMock(return_value=False)) ) monkeypatch.setitem(sys.modules, "app.services.user_cart_service", user_cart_stub) class DummyTypes: class InlineKeyboardMarkup: def __init__(self, inline_keyboard=None, **kwargs): self.inline_keyboard = inline_keyboard or [] self.kwargs = kwargs class InlineKeyboardButton: def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs monkeypatch.setitem(sys.modules, "aiogram", SimpleNamespace(types=DummyTypes)) service.build_topup_success_keyboard = AsyncMock(return_value=None) result = await service.get_pal24_payment_status(fake_session, payment.id) assert result is not None assert payment.transaction_id == 999 assert user.balance_kopeks == 5000 assert bot.sent_messages assert admin_notifications assert transactions and transactions[0]["user_id"] == 91 @pytest.mark.anyio("asyncio") async def test_process_pal24_callback_payment_not_found(monkeypatch: pytest.MonkeyPatch) -> None: bot = DummyBot() service = _make_service(bot) service.pal24_service = SimpleNamespace(is_configured=True) db = FakeSession() async def fake_get_by_order(db, order_id): return None async def fake_get_by_bill(db, bill_id): return None pal_module = ModuleType("app.database.crud.pal24") pal_module.get_pal24_payment_by_order_id = fake_get_by_order pal_module.get_pal24_payment_by_bill_id = fake_get_by_bill pal_module.update_pal24_payment_status = AsyncMock() pal_module.link_pal24_payment_to_transaction = AsyncMock() monkeypatch.setitem(sys.modules, "app.database.crud.pal24", pal_module) monkeypatch.setattr(payment_service_module, "get_pal24_payment_by_order_id", fake_get_by_order) monkeypatch.setattr(payment_service_module, "get_pal24_payment_by_bill_id", fake_get_by_bill) payload = { "InvId": "order-unknown", "OutSum": "10.00", "Status": "SUCCESS", } result = await service.process_pal24_callback(db, payload) assert result is False