✨(ingestion) create a shared Talensoft front client (#599)

* ✨(ingestion) create a shared Talensoft front client

* ♻️(ingestion) revert changes to async client

* ✅(ingestion) test requests share the same token

* ✅(ingestion) test token is fetched once with different webhooks

Author: AntoineAugusti

src/ingestion/api/routes.py

@@ -1,9 +1,10 @@
 import logging
-from collections.abc import AsyncGenerator
+from typing import Callable, TypeVar
 
 from dependency_injector.wiring import Provide, inject
 from fastapi import APIRouter, Depends, HTTPException, Query, Request
 from pydantic import ValidationError
+from starlette.datastructures import State
 
 from api.config import Settings, get_settings
 from api.talentsoft import verify_talentsoft_signature
@@ -27,24 +28,44 @@
 
 _OK = {"status": "ok"}
 
+_T = TypeVar("_T")
 
-async def get_load_offer_details_use_case(
+
+def _state_setdefault(state: State, key: str, factory: Callable[[], _T]) -> _T:
+    if not hasattr(state, key):
+        setattr(state, key, factory())
+    return getattr(state, key)
+
+
+def get_load_offer_details_use_case(
+    request: Request,
     settings: Settings = Depends(get_settings),
-) -> AsyncGenerator[LoadOfferDetailsUseCase | None, None]:
+) -> LoadOfferDetailsUseCase | None:
     if (
         not settings.talentsoft_front_client_id
         or not settings.talentsoft_front_client_secret
         or not settings.talentsoft_front_base_url
     ):
-        yield None
-    else:
+        return None
+
+    base_url = settings.talentsoft_front_base_url
+    client_id = settings.talentsoft_front_client_id
+    client_secret = settings.talentsoft_front_client_secret
+
+    def _make_client() -> TalentsoftFrontClient:
         config = TalentsoftConfig(
-            base_url=settings.talentsoft_front_base_url,
-            client_id=settings.talentsoft_front_client_id,
-            client_secret=settings.talentsoft_front_client_secret,
+            base_url=base_url,
+            client_id=client_id,
+            client_secret=client_secret,
         )
-        async with TalentsoftFrontClient(config=config, logger=logger) as client:
-            yield LoadOfferDetailsUseCase(talentsoft_client=client)
+        return TalentsoftFrontClient(config=config, logger=logger)
+
+    client = _state_setdefault(
+        request.app.state,
+        "talentsoft_front_client",
+        _make_client,
+    )
+    return LoadOfferDetailsUseCase(talentsoft_client=client)
 
 
 @public_router.get("/health")

src/ingestion/infrastructure/gateways/async_http_client.py

@@ -6,7 +6,7 @@
 class AsyncHttpClient:
     def __init__(self, timeout: int = 120):
         self.timeout = timeout
-        self._client: Optional[httpx.AsyncClient] = None
+        self._client: Optional[httpx.AsyncClient] = httpx.AsyncClient(timeout=timeout)
 
     async def __aenter__(self) -> Self:
         self._client = httpx.AsyncClient(timeout=self.timeout)

src/ingestion/tests/presentation/test_webhook_load_offer.py

@@ -162,3 +162,39 @@ async def test_other_event_type_does_not_call_talentsoft(
 
     assert response.status_code == 200
     assert httpx_mock.get_requests() == []
+
+
+@pytest.mark.asyncio
+async def test_token_is_fetched_once_across_two_webhook_requests(
+    talentsoft_client, httpx_mock: HTTPXMock
+):
+    reference_2 = "2024-VACANCY-002"
+
+    _mock_token_response(httpx_mock)
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{DETAIL_OFFER_URL}?reference={REFERENCE}",
+        json=_detail_offer_payload(REFERENCE),
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{DETAIL_OFFER_URL}?reference={reference_2}",
+        json=_detail_offer_payload(reference_2),
+    )
+
+    response_1 = make_signed_request(
+        talentsoft_client, {"event_type": "vacancy_new", "reference": REFERENCE}
+    )
+    response_2 = make_signed_request(
+        talentsoft_client, {"event_type": "vacancy_new", "reference": reference_2}
+    )
+
+    assert response_1.status_code == 200
+    assert response_2.status_code == 200
+
+    requests = httpx_mock.get_requests()
+    # 1 token request + 2 detail requests.
+    # token is not fetched again on the second webhook call
+    assert len(requests) == 3
+    token_requests = [r for r in requests if str(r.url) == TOKEN_URL]
+    assert len(token_requests) == 1

src/ingestion/tests/unit/external_gateways/test_talentsoft_client.py

@@ -196,6 +196,44 @@ async def test_get_detail_fails_due_to_unauthorized_token(self, talentsoft_clien
             assert mock_get.call_count == 2
             mock_post.assert_called_once()  # Token refresh called
 
+    @pytest.mark.asyncio
+    async def test_token_is_fetched_once_when_client_is_shared_across_requests(
+        self, talentsoft_client
+    ):
+        response_data_1 = detail_offer_response()
+        response_data_2 = detail_offer_response()
+        token_response = {
+            "access_token": fake.uuid4(),
+            "token_type": fake.word(),
+            "expires_in": 3600,
+        }
+
+        talentsoft_client.cached_token = None
+
+        with (
+            patch.object(talentsoft_client, "get", new_callable=AsyncMock) as mock_get,
+            patch.object(
+                talentsoft_client, "post", new_callable=AsyncMock
+            ) as mock_post,
+        ):
+            mock_get.side_effect = [
+                mocked_response(return_value=response_data_1),
+                mocked_response(return_value=response_data_2),
+            ]
+            mock_post.return_value = mocked_response(return_value=token_response)
+
+            offer_1 = await talentsoft_client.get_detail(
+                reference=response_data_1["reference"]
+            )
+            offer_2 = await talentsoft_client.get_detail(
+                reference=response_data_2["reference"]
+            )
+
+        assert offer_1.reference == response_data_1["reference"]
+        assert offer_2.reference == response_data_2["reference"]
+        mock_post.assert_called_once()  # Token was fetched only once, not per request
+        assert mock_get.call_count == 2
+
     @pytest.mark.asyncio
     async def test_get_detail_fails_after_max_retries_attempts(self, talentsoft_client):
         failed_response = mocked_response(status_code=500)

src/ingestion/tests/unit/test_async_http_client.py

@@ -1,17 +1,28 @@
 import pytest
+from pytest_httpx import HTTPXMock
 
 from infrastructure.gateways.async_http_client import AsyncHttpClient
 
 
 @pytest.mark.asyncio
-async def test_post_without_context_manager_raises():
+async def test_post_without_context_manager_succeeds(httpx_mock: HTTPXMock):
+    httpx_mock.add_response(method="POST", url="https://example.com")
     client = AsyncHttpClient()
-    with pytest.raises(RuntimeError, match="Client not initialized"):
-        await client.post("https://example.com")
+    response = await client.post("https://example.com")
+    assert response.status_code == 200
 
 
 @pytest.mark.asyncio
-async def test_get_without_context_manager_raises():
+async def test_get_without_context_manager_succeeds(httpx_mock: HTTPXMock):
+    httpx_mock.add_response(method="GET", url="https://example.com")
     client = AsyncHttpClient()
-    with pytest.raises(RuntimeError, match="Client not initialized"):
+    response = await client.get("https://example.com")
+    assert response.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_aclose_cleans_up_client(httpx_mock: HTTPXMock):
+    httpx_mock.add_response(method="GET", url="https://example.com")
+    async with AsyncHttpClient() as client:
         await client.get("https://example.com")
+    assert client._client is None