Раис Юсупалиев
330 lines
10 KiB
Python
330 lines
10 KiB
Python
import asyncio
|
|
from decimal import Decimal
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from app.controllers.v1 import delivery as delivery_controller
|
|
from app.controllers.v1.delivery import get_aggregator_service
|
|
from app.main import create_app
|
|
from app.schemas.request import DeliveryEntity, DeliveryRequest
|
|
from app.schemas.response import DeliveryPrice
|
|
from app.services.aggregator import (
|
|
AggregatorServiceError,
|
|
InvalidDeliveryRequestError,
|
|
)
|
|
|
|
|
|
class StubAggregatorService:
|
|
def __init__(self, *, response: object, error: Exception | None = None) -> None:
|
|
self._response = response
|
|
self._error = error
|
|
self.calls: list[DeliveryRequest] = []
|
|
|
|
async def get_all_prices(self, request: DeliveryRequest) -> object:
|
|
self.calls.append(request)
|
|
if self._error is not None:
|
|
raise self._error
|
|
return self._response
|
|
|
|
|
|
def _install_service_override(app, service: StubAggregatorService) -> None:
|
|
async def override_service() -> StubAggregatorService:
|
|
return service
|
|
|
|
app.dependency_overrides[get_aggregator_service] = override_service
|
|
|
|
|
|
def _valid_payload() -> dict[str, object]:
|
|
return {
|
|
"entity": "individual",
|
|
"from_city": "Moscow",
|
|
"to_city": "Kazan",
|
|
"weight_kg": 2.5,
|
|
"length_cm": 30.0,
|
|
"width_cm": 20.0,
|
|
"height_cm": 10.0,
|
|
}
|
|
|
|
|
|
def test_post_delivery_price_uses_registered_provider_in_default_dependency(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
class StubHttpClient:
|
|
def __init__(self) -> None:
|
|
self.closed = False
|
|
|
|
async def aclose(self) -> None:
|
|
self.closed = True
|
|
|
|
class StubProvider:
|
|
name = "stub-provider"
|
|
cache_ttl_seconds = 900
|
|
|
|
def __init__(self) -> None:
|
|
self.calls: list[DeliveryRequest] = []
|
|
|
|
async def get_price(self, request: DeliveryRequest) -> DeliveryPrice:
|
|
self.calls.append(request)
|
|
return DeliveryPrice(
|
|
provider=self.name,
|
|
service_name="stub-service",
|
|
price=Decimal("123.50"),
|
|
currency="RUB",
|
|
delivery_days_min=2,
|
|
delivery_days_max=3,
|
|
)
|
|
|
|
class StubCDEKProvider:
|
|
@classmethod
|
|
def from_adapter_config(cls, *, http_client, adapter_config) -> StubProvider:
|
|
assert http_client is stub_http_client
|
|
_ = adapter_config
|
|
return stub_provider
|
|
|
|
class StubCache:
|
|
def __init__(self) -> None:
|
|
self.storage: dict[str, object] = {}
|
|
|
|
async def get(self, key: str) -> object | None:
|
|
return self.storage.get(key)
|
|
|
|
async def set(self, key: str, value: object, ttl: int | None = None) -> None:
|
|
_ = ttl
|
|
self.storage[key] = value
|
|
|
|
class StubPriceCache:
|
|
@classmethod
|
|
def from_repository_config(cls, repository_config) -> StubCache:
|
|
_ = repository_config
|
|
return stub_cache
|
|
|
|
stub_http_client = StubHttpClient()
|
|
stub_provider = StubProvider()
|
|
stub_cache = StubCache()
|
|
http_client_timeouts: list[float] = []
|
|
|
|
def fake_build_controller_http_client(timeout_seconds: float) -> StubHttpClient:
|
|
http_client_timeouts.append(timeout_seconds)
|
|
return stub_http_client
|
|
|
|
monkeypatch.setattr(
|
|
delivery_controller,
|
|
"build_controller_http_client",
|
|
fake_build_controller_http_client,
|
|
)
|
|
monkeypatch.setattr(delivery_controller, "CDEKProvider", StubCDEKProvider)
|
|
monkeypatch.setattr(delivery_controller, "PriceCache", StubPriceCache)
|
|
|
|
app = create_app()
|
|
|
|
async def run_requests() -> tuple[httpx.Response, httpx.Response]:
|
|
transport = httpx.ASGITransport(app=app)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
first = await client.post("/api/v1/delivery/price", json=_valid_payload())
|
|
second = await client.post("/api/v1/delivery/price", json=_valid_payload())
|
|
return first, second
|
|
|
|
first_response, second_response = asyncio.run(run_requests())
|
|
|
|
assert first_response.status_code == 200
|
|
assert second_response.status_code == 200
|
|
assert first_response.json() == [
|
|
{
|
|
"provider": "stub-provider",
|
|
"service_name": "stub-service",
|
|
"price": "124",
|
|
"currency": "RUB",
|
|
"delivery_days_min": 2,
|
|
"delivery_days_max": 3,
|
|
}
|
|
]
|
|
assert second_response.json() == first_response.json()
|
|
assert len(http_client_timeouts) == 1
|
|
assert len(stub_provider.calls) == 1
|
|
|
|
|
|
def test_post_delivery_price_returns_prices_and_delegates_to_service() -> None:
|
|
expected_price = DeliveryPrice(
|
|
provider="cdek",
|
|
service_name="express",
|
|
price=Decimal("100.50"),
|
|
currency="RUB",
|
|
delivery_days_min=1,
|
|
delivery_days_max=2,
|
|
)
|
|
service = StubAggregatorService(response=[expected_price])
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.post("/api/v1/delivery/price", json=_valid_payload())
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 200
|
|
assert response.json() == [expected_price.model_dump(mode="json")]
|
|
assert len(service.calls) == 1
|
|
assert service.calls[0] == DeliveryRequest(
|
|
entity=DeliveryEntity.INDIVIDUAL,
|
|
from_city="Moscow",
|
|
to_city="Kazan",
|
|
country_code=None,
|
|
weight_kg=2.5,
|
|
length_cm=30.0,
|
|
width_cm=20.0,
|
|
height_cm=10.0,
|
|
)
|
|
|
|
|
|
def test_post_delivery_price_accepts_optional_country_code() -> None:
|
|
service = StubAggregatorService(response=[])
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
payload = _valid_payload()
|
|
payload["country_code"] = "kz"
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.post("/api/v1/delivery/price", json=payload)
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 200
|
|
assert len(service.calls) == 1
|
|
assert service.calls[0].country_code == "kz"
|
|
|
|
|
|
def test_post_delivery_price_rejects_invalid_payload() -> None:
|
|
service = StubAggregatorService(response=[])
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
invalid_payload = _valid_payload()
|
|
invalid_payload["weight_kg"] = 0
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.post("/api/v1/delivery/price", json=invalid_payload)
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 422
|
|
assert service.calls == []
|
|
|
|
|
|
def test_post_delivery_price_maps_service_exception_to_503() -> None:
|
|
service = StubAggregatorService(
|
|
response=[],
|
|
error=AggregatorServiceError("service unavailable"),
|
|
)
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.post("/api/v1/delivery/price", json=_valid_payload())
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 503
|
|
assert response.json() == {
|
|
"detail": {
|
|
"code": "aggregator_service_error",
|
|
"message": "Delivery price aggregation is temporarily unavailable.",
|
|
}
|
|
}
|
|
|
|
|
|
def test_post_delivery_price_maps_invalid_request_to_400() -> None:
|
|
service = StubAggregatorService(
|
|
response=[],
|
|
error=InvalidDeliveryRequestError("city not found"),
|
|
)
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.post("/api/v1/delivery/price", json=_valid_payload())
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 400
|
|
assert response.json() == {
|
|
"detail": {
|
|
"code": "invalid_delivery_request",
|
|
"message": "Delivery request contains unknown or unsupported location.",
|
|
}
|
|
}
|
|
|
|
|
|
def test_delivery_price_endpoint_accepts_only_post_method() -> None:
|
|
service = StubAggregatorService(response=[])
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.get("/api/v1/delivery/price")
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 405
|
|
|
|
|
|
def test_post_delivery_price_enforces_response_schema() -> None:
|
|
service = StubAggregatorService(
|
|
response=[
|
|
{
|
|
"provider": "cdek",
|
|
"service_name": "express",
|
|
"price": "100.50",
|
|
"currency": "R",
|
|
"delivery_days_min": 1,
|
|
"delivery_days_max": 2,
|
|
}
|
|
]
|
|
)
|
|
app = create_app()
|
|
_install_service_override(app, service)
|
|
|
|
async def run_request() -> httpx.Response:
|
|
transport = httpx.ASGITransport(app=app, raise_app_exceptions=False)
|
|
async with httpx.AsyncClient(
|
|
transport=transport,
|
|
base_url="http://testserver",
|
|
) as client:
|
|
return await client.post("/api/v1/delivery/price", json=_valid_payload())
|
|
|
|
response = asyncio.run(run_request())
|
|
|
|
assert response.status_code == 500
|