g2s-aggregator/tests/controllers/v1/test_address_suggestions.py

import asyncio

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 AddressSuggestRequest
from app.schemas.response import AddressSuggestion
from app.services.aggregator import (
    AddressSuggestionsUnavailableError,
    InvalidAddressSuggestRequestError,
    UnsupportedAddressSuggestionCountryError,
)


class StubAggregatorService:
    def __init__(self, *, response: object, error: Exception | None = None) -> None:
        self._response = response
        self._error = error
        self.calls: list[AddressSuggestRequest] = []

    async def suggest_addresses(self, request: AddressSuggestRequest) -> 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 {
        "country_code": "RU",
        "city": "Moscow",
        "query": "Lenina",
        "limit": 5,
    }


def test_post_address_suggest_uses_registered_provider_in_default_dependency(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    class StubHttpClient:
        async def aclose(self) -> None:
            return None

    class StubCDEKProvider:
        name = "stub-cdek"
        cache_ttl_seconds = 900

        @classmethod
        def from_adapter_config(cls, *, http_client, adapter_config) -> "StubCDEKProvider":
            assert http_client is stub_http_client
            _ = adapter_config
            return cls()

    class StubAddressProvider:
        name = "dadata"

        def __init__(self) -> None:
            self.calls: list[AddressSuggestRequest] = []

        async def suggest(
            self, request: AddressSuggestRequest
        ) -> list[AddressSuggestion]:
            self.calls.append(request)
            return [
                AddressSuggestion(
                    address="107241, Moscow, Khabarovskaya 1",
                    street="Khabarovskaya",
                    house="1",
                    flat="25",
                    postal_code="107241",
                )
            ]

    class StubDadataAddressSuggestionProvider:
        @classmethod
        def from_config(
            cls,
            *,
            http_client,
            config,
        ) -> StubAddressProvider:
            assert http_client is stub_http_client
            _ = config
            return stub_address_provider

    class StubCache:
        async def get(self, key: str) -> object | None:
            _ = key
            return None

        async def set(self, key: str, value: object, ttl: int | None = None) -> None:
            _ = key
            _ = value
            _ = ttl

    class StubPriceCache:
        @classmethod
        def from_repository_config(cls, repository_config) -> StubCache:
            _ = repository_config
            return StubCache()

    stub_http_client = StubHttpClient()
    stub_address_provider = StubAddressProvider()
    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,
        "DadataAddressSuggestionProvider",
        StubDadataAddressSuggestionProvider,
    )
    monkeypatch.setattr(delivery_controller, "PriceCache", StubPriceCache)

    app = create_app()

    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/suggest-address",
                json=_valid_payload(),
            )

    response = asyncio.run(run_request())

    assert response.status_code == 200
    assert response.json() == [
        {
            "address": "107241, Moscow, Khabarovskaya 1",
            "street": "Khabarovskaya",
            "house": "1",
            "flat": "25",
            "postal_code": "107241",
        }
    ]
    assert http_client_timeouts == [10.0]
    assert stub_address_provider.calls == [AddressSuggestRequest(**_valid_payload())]


def test_post_address_suggest_returns_response_and_delegates_to_service() -> None:
    expected_response = [
        AddressSuggestion(
            address="107241, Moscow, Khabarovskaya 1",
            street="Khabarovskaya",
            house="1",
            flat="25",
            postal_code="107241",
        )
    ]
    service = StubAggregatorService(response=expected_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.post(
                "/api/v1/delivery/suggest-address",
                json=_valid_payload(),
            )

    response = asyncio.run(run_request())

    assert response.status_code == 200
    assert response.json() == [item.model_dump(mode="json") for item in expected_response]
    assert service.calls == [AddressSuggestRequest(**_valid_payload())]


@pytest.mark.parametrize(
    ("field_name", "field_value"),
    [("country_code", "RUS"), ("limit", 0), ("query", "")],
)
def test_post_address_suggest_rejects_invalid_payload(
    field_name: str,
    field_value: object,
) -> None:
    service = StubAggregatorService(response=[])
    app = create_app()
    _install_service_override(app, service)
    payload = _valid_payload()
    payload[field_name] = field_value

    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/suggest-address",
                json=payload,
            )

    response = asyncio.run(run_request())

    assert response.status_code == 422
    assert service.calls == []


def test_post_address_suggest_maps_unsupported_country_to_400() -> None:
    service = StubAggregatorService(
        response=None,
        error=UnsupportedAddressSuggestionCountryError("unsupported country"),
    )
    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/suggest-address",
                json=_valid_payload(),
            )

    response = asyncio.run(run_request())

    assert response.status_code == 400
    assert response.json() == {
        "detail": {
            "code": "unsupported_address_suggestion_country",
            "message": "Address suggestions are not configured for the requested country.",
        }
    }


def test_post_address_suggest_maps_invalid_request_to_400() -> None:
    service = StubAggregatorService(
        response=None,
        error=InvalidAddressSuggestRequestError("provider rejected request"),
    )
    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/suggest-address",
                json=_valid_payload(),
            )

    response = asyncio.run(run_request())

    assert response.status_code == 400
    assert response.json() == {
        "detail": {
            "code": "invalid_address_suggest_request",
            "message": "Address suggestion request contains invalid or unsupported provider data.",
        }
    }


def test_post_address_suggest_maps_service_exception_to_503() -> None:
    service = StubAggregatorService(
        response=None,
        error=AddressSuggestionsUnavailableError("provider 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/suggest-address",
                json=_valid_payload(),
            )

    response = asyncio.run(run_request())

    assert response.status_code == 503
    assert response.json() == {
        "detail": {
            "code": "address_suggestions_unavailable",
            "message": "Address suggestions are temporarily unavailable.",
        }
    }