# Make FastAPI testable

Shows how providing "services" for depency injection is important for testing and how such services could be easily mocked.

Consider the following endpoint:

```python
router = APIRouter(
    prefix="/api/v1"
)

@router.get("/partners",
            dependencies=[Depends(verify_api_key)])
async def get_partners(
    partner_service: Annotated[PartnerService, Depends(get_partner_service)],
    ocpi_from_country_code: Annotated[str | None, Header()] = None,
):
    partners = await partner_service.get_all_partners(ocpi_from_country_code)
    return partners
```

From Python's point of view *partner_service* is the default parameter because it uses default-argument syntax (*param=value*) , but in FastAPI it acts as a dependency injection.

The simplest test for it should be with TestClient from FastAPI (actually from starlette on httpx2) or with ASGITransport from httpx :

```python
@pytest.mark.asyncio
async def test_get_partner(app):    
    from fastapi.testclient import TestClient
    client = TestClient(app)

    # from httpx import ASGITransport, AsyncClient
    # transport = ASGITransport(app=app)
    # async with AsyncClient(transport=transport, base_url="http://test") as client:
    #     response = await client.get(
    #          "/api/v1/partners",
    #         headers={
    #             "X-API-KEY": API_KEY,
    #             "ocpi-from-country-code": "IL",
    #         }
    #     )


    response = client.get(
        "/api/v1/partners",
        headers={
            "X-API-KEY": API_KEY,
            "ocpi-from-country-code": "IL",
        },
    )
    assert response.status_code == 200
```

FastAPI will inject the PartnerService and use it.

With AsyncMock from pytest this service could be mocked:

```python
@pytest.mark.asyncio
async def test_get_all_partners():
    from ocpi.main import create_app
    from ocpi.verify_api_key import verify_api_key

    app = create_app()
    app.dependency_overrides[verify_api_key] = lambda: True

    get_all_partners = AsyncMock(
        return_value=[{
            "party_id": "CPO",
            "country_code": "IL",
        }]
    )
    partner_service = SimpleNamespace(get_all_partners=get_all_partners)
    app.dependency_overrides[get_partner_service] = lambda: partner_service

    from fastapi.testclient import TestClient
    client = TestClient(app)
    response = client.get(
        "/api/v1/partners",
        headers={
            "X-API-KEY": API_KEY,
            "ocpi-from-country-code": "IL",
        },
    )
    assert response.status_code == 200
    assert response.json()[0]["party_id"] == "CPO"
    get_all_partners.assert_awaited_once_with("IL")
```

sdsa
