import asyncio from decimal import Decimal import pytest from app.adapters.delivery_providers.base import ProviderRequestError from app.schemas.request import DeliveryEntity, DeliveryRequest from app.schemas.response import DeliveryPrice from app.services.aggregator import AggregatorService, InvalidDeliveryRequestError _MISSING = object() class StubProvider: def __init__( self, name: str, *, response: DeliveryPrice | None = None, error: Exception | None = None, cache_ttl_seconds: int = 900, ) -> None: self.name = name self._response = response self._error = error self.cache_ttl_seconds = cache_ttl_seconds self.calls: list[DeliveryRequest] = [] async def get_price(self, request: DeliveryRequest) -> DeliveryPrice: self.calls.append(request) if self._error is not None: raise self._error if self._response is None: raise RuntimeError("Stub provider has no response configured.") return self._response class StubCache: def __init__( self, *, forced_get_value: object = _MISSING, ) -> None: self._storage: dict[str, object] = {} self._forced_get_value = forced_get_value self.get_calls: list[str] = [] self.set_calls: list[tuple[str, object, int | None]] = [] async def get(self, key: str) -> object | None: self.get_calls.append(key) if self._forced_get_value is not _MISSING: return self._forced_get_value return self._storage.get(key) async def set(self, key: str, value: object, ttl: int | None = None) -> None: self.set_calls.append((key, value, ttl)) self._storage[key] = value def _make_request(**overrides: object) -> DeliveryRequest: payload: dict[str, object] = { "entity": DeliveryEntity.INDIVIDUAL, "from_city": "Moscow", "to_city": "Kazan", "country_code": None, "weight_kg": 1.234, "length_cm": 30.0, "width_cm": 20.0, "height_cm": 10.0, } payload.update(overrides) return DeliveryRequest(**payload) def _make_price(provider: str, price: str) -> DeliveryPrice: return DeliveryPrice( provider=provider, service_name="standard", price=Decimal(price), currency="RUB", delivery_days_min=2, delivery_days_max=4, ) def test_get_all_prices_full_success_returns_sorted_and_updates_cache() -> None: provider_a = StubProvider(name="a", response=_make_price("a", "300.49"), cache_ttl_seconds=111) provider_b = StubProvider(name="b", response=_make_price("b", "100.40"), cache_ttl_seconds=222) cache = StubCache() service = AggregatorService( [provider_a, provider_b], cache=cache, provider_price_multiplier=Decimal("1.1"), ) result = asyncio.run(service.get_all_prices(_make_request())) assert [price.provider for price in result] == ["b", "a"] assert [price.price for price in result] == [Decimal("110"), Decimal("331")] assert len(provider_a.calls) == 1 assert len(provider_b.calls) == 1 assert len(cache.get_calls) == 2 assert [ttl for _, _, ttl in cache.set_calls] == [111, 222] def test_get_all_prices_normalizes_and_forwards_country_code_to_providers() -> None: provider = StubProvider(name="cdek", response=_make_price("cdek", "150.00")) service = AggregatorService([provider], cache=StubCache()) result = asyncio.run(service.get_all_prices(_make_request(country_code=" kz "))) assert [price.provider for price in result] == ["cdek"] assert len(provider.calls) == 1 assert provider.calls[0].country_code == "KZ" def test_get_all_prices_partial_failure_excludes_failed_provider() -> None: provider_ok = StubProvider(name="ok", response=_make_price("ok", "150.00")) provider_failed = StubProvider(name="failed", error=RuntimeError("provider unavailable")) service = AggregatorService([provider_ok, provider_failed], cache=StubCache()) result = asyncio.run(service.get_all_prices(_make_request())) assert [price.provider for price in result] == ["ok"] assert len(provider_ok.calls) == 1 assert len(provider_failed.calls) == 1 def test_get_all_prices_all_failures_returns_empty_list() -> None: provider_a = StubProvider(name="a", error=RuntimeError("a down")) provider_b = StubProvider(name="b", error=RuntimeError("b down")) service = AggregatorService([provider_a, provider_b], cache=StubCache()) result = asyncio.run(service.get_all_prices(_make_request())) assert result == [] assert len(provider_a.calls) == 1 assert len(provider_b.calls) == 1 def test_get_all_prices_raises_invalid_request_for_provider_request_errors() -> None: provider = StubProvider( name="cdek", error=ProviderRequestError("city not found"), ) service = AggregatorService([provider], cache=StubCache()) with pytest.raises(InvalidDeliveryRequestError): asyncio.run(service.get_all_prices(_make_request())) assert len(provider.calls) == 1 def test_get_all_prices_cache_hit_skips_provider_call() -> None: cached_payload = _make_price("cdek", "100.40").model_dump(mode="json") cache = StubCache(forced_get_value=cached_payload) provider = StubProvider(name="cdek", response=_make_price("cdek", "150.00")) service = AggregatorService( [provider], cache=cache, provider_price_multiplier=Decimal("1.1"), ) result = asyncio.run(service.get_all_prices(_make_request())) assert [price.provider for price in result] == ["cdek"] assert result[0].price == Decimal("110") assert provider.calls == [] assert len(cache.get_calls) == 1 assert cache.set_calls == [] def test_get_all_prices_delegates_filtering_and_sorting_to_domain_logic() -> None: provider_a = StubProvider(name="a", response=_make_price("a", "300.00")) provider_b = StubProvider(name="b", response=_make_price("b", "100.00")) delegated_inputs: list[list[DeliveryPrice]] = [] delegated_multipliers: list[Decimal] = [] def fake_filter_and_sort(prices, *, price_multiplier): price_list = list(prices) delegated_inputs.append(price_list) delegated_multipliers.append(price_multiplier) return [price_list[0]] service = AggregatorService( [provider_a, provider_b], cache=StubCache(), provider_price_multiplier=Decimal("1.23"), filter_and_sort_prices_fn=fake_filter_and_sort, ) result = asyncio.run(service.get_all_prices(_make_request())) assert [price.provider for price in delegated_inputs[0]] == ["a", "b"] assert delegated_multipliers == [Decimal("1.23")] assert [price.provider for price in result] == ["a"]