File size: 11,683 Bytes
cd71f3c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
57c8117
cd71f3c
 
 
57c8117
cd71f3c
 
 
 
 
57c8117
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cd71f3c
 
 
 
 
 
 
 
 
 
57c8117
cd71f3c
 
57c8117
c6e37b4
 
57c8117
cd71f3c
 
 
 
 
 
 
195c1c3
cd71f3c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
c6e37b4
 
 
 
 
 
 
 
cd71f3c
 
 
 
 
 
 
 
 
c6e37b4
cd71f3c
 
c6e37b4
 
195c1c3
 
cd71f3c
 
 
195c1c3
cd71f3c
 
 
 
 
 
 
 
 
 
57c8117
cd71f3c
 
 
 
 
 
 
 
 
 
 
 
195c1c3
c6e37b4
 
cd71f3c
 
 
 
 
 
 
 
 
 
 
195c1c3
cd71f3c
 
 
 
ca74a6b
 
 
 
 
 
 
 
57c8117
ca74a6b
 
 
 
 
 
 
57c8117
ca74a6b
 
 
 
 
57c8117
ca74a6b
 
 
 
 
 
 
 
 
 
 
57c8117
 
 
 
 
 
 
 
 
 
7dc0e8b
 
 
 
 
 
 
 
 
 
 
 
 
 
57c8117
 
 
7dc0e8b
57c8117
7dc0e8b
57c8117
7dc0e8b
 
 
 
 
 
 
 
 
 
 
 
 
 
b9769d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
57c8117
b9769d8
57c8117
 
 
b9769d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
"""
Tests de la dimension, de la normalisation et de la cle de cache des embeddings.

Chaque test correspond a un mecanisme qui n'existait pas :

- output_dimensionality n'etait pas demande a l'API ;
- la renormalisation des sorties tronquees (Matryoshka) n'existait pas, alors
  que l'operateur <=> de pgvector suppose des vecteurs unitaires ;
- le chemin batch n'avait ni garde de dimension ni controle du nombre de
  vecteurs rendus ;
- la cle de cache ignorait la dimension (un vecteur 3072 aurait ete resservi
  sous configuration 1536) et minusculait le texte.
"""

import json

import httpx
import numpy as np
import pytest

from app.services import embedding_service as module
from app.services.embedding_service import EmbeddingService, EmbeddingServiceError


@pytest.fixture
def recorder(monkeypatch):
    """Doublure HTTP de Voyage qui enregistre le corps de chaque requete."""
    state = {"payloads": [], "n_returned": None, "dim": None, "scale": 9.0}

    def _repondre(requete: httpx.Request) -> httpx.Response:
        payload = json.loads(requete.content)
        state["payloads"].append(payload)
        dim = state["dim"] or payload["output_dimension"]
        n = state["n_returned"] if state["n_returned"] is not None else len(payload["input"])
        rng = np.random.default_rng(7)
        # Vecteurs NON unitaires : c'est le service qui doit normaliser.
        return httpx.Response(200, json={"data": [
            {"index": i, "embedding": (rng.random(dim) * state["scale"]).tolist()}
            for i in range(n)
        ]})

    monkeypatch.setattr(module, "transport_http", httpx.MockTransport(_repondre))
    return state


@pytest.fixture
def service(recorder):
    return EmbeddingService(use_cache=False)


class TestDimension:

    def test_output_dimension_is_requested(self, service, recorder):
        service.generate_embedding("Article premier du code civil")

        assert recorder["payloads"][-1]["output_dimension"] == EmbeddingService.EMBEDDING_DIM
        # Valeur absolue et non derivee : le but est de remarquer un changement
        # accidentel de dimension, pas de le suivre.
        assert EmbeddingService.EMBEDDING_DIM == 1024

    def test_embedding_has_configured_dimension(self, service):
        embedding = service.generate_embedding("Article premier")

        assert embedding.shape == (EmbeddingService.EMBEDDING_DIM,)

    def test_batch_rejects_wrong_dimension(self, service, recorder):
        recorder["dim"] = 512  # l'API renvoie autre chose que ce qui est demande

        with pytest.raises(EmbeddingServiceError, match="Dimension"):
            service.generate_batch_embeddings(["a", "b"])

    def test_batch_rejects_truncated_response(self, service, recorder):
        """
        Deux vecteurs pour trois textes : zip() perdait silencieusement la
        queue du lot, puis un KeyError tombait bien plus loin.
        """
        recorder["n_returned"] = 2

        with pytest.raises(EmbeddingServiceError, match="incomplète"):
            service.generate_batch_embeddings(["a", "b", "c"])


class TestNormalisation:

    def test_embedding_is_unit_norm(self, service):
        embedding = service.generate_embedding("Responsabilité des dirigeants")

        assert abs(float(np.linalg.norm(embedding)) - 1.0) < 1e-5

    def test_batch_embeddings_are_unit_norm(self, service):
        embeddings = service.generate_batch_embeddings(["un", "deux", "trois"])

        for embedding in embeddings:
            assert abs(float(np.linalg.norm(embedding)) - 1.0) < 1e-5

    def test_normalisation_applies_even_when_not_requested(self, service):
        """
        La normalisation est INCONDITIONNELLE, a toute dimension y compris la
        native.

        Une version precedente la sautait quand normalize=False a la dimension
        native, en supposant que l'API renvoie deja un vecteur unitaire. C'est
        vrai de l'API, mais ca fait dependre d'un reglage une garantie dont tout
        l'aval depend : similarity() est un np.dot nu, et le score
        1 - distance borne a [0, 1] ne vaut que sur la sphere unite.
        """
        embedding = service.generate_embedding("Test", normalize=False)

        assert abs(float(np.linalg.norm(embedding)) - 1.0) < 1e-5


class TestCacheKey:

    def test_key_isolates_dimension(self, service):
        key_native = service._cache_key("texte", EmbeddingService.TASK_DOCUMENT)
        original = EmbeddingService.EMBEDDING_DIM
        try:
            # Une dimension differente de celle configuree, sinon les deux cles
            # sont identiques et le test ne verifie rien.
            service.EMBEDDING_DIM = 512
            key_512 = service._cache_key("texte", EmbeddingService.TASK_DOCUMENT)
        finally:
            service.EMBEDDING_DIM = original

        assert key_native != key_512

    def test_key_isolates_task_type(self, service):
        as_document = service._cache_key("texte", EmbeddingService.TASK_DOCUMENT)
        as_query = service._cache_key("texte", EmbeddingService.TASK_QUERY)

        assert as_document != as_query

    def test_key_is_case_sensitive(self, service):
        """
        La cle minusculait le texte : "Article PREMIER" et "article premier"
        partageaient une entree alors que le modele les encode differemment.
        """
        upper = service._cache_key("Article PREMIER", EmbeddingService.TASK_DOCUMENT)
        lower = service._cache_key("article premier", EmbeddingService.TASK_DOCUMENT)

        assert upper != lower


class TestCacheRead:

    @pytest.mark.asyncio
    async def test_cache_read_rejects_wrong_dimension(self, recorder, db_session):
        """
        Une entree ecrite sous une autre dimension (ici 3072, la configuration
        precedente) doit etre ignoree, pas servie : elle serait rejetee par la
        colonne, ou pire, comparee de travers.
        """
        from sqlalchemy import text as sql_text

        service = EmbeddingService(use_cache=True)
        key = service._cache_key("texte périmé", EmbeddingService.TASK_DOCUMENT)

        await db_session.execute(
            sql_text(
                "INSERT INTO embedding_cache (text_hash, embedding_json, expires_at) "
                "VALUES (:key, :data, now() + interval '1 day')"
            ),
            {"key": key, "data": json.dumps([0.1] * 3072)},
        )
        await db_session.commit()

        assert service._get_from_pg_cache(key) is None


class TestOffLoop:

    @pytest.mark.asyncio
    async def test_generate_embedding_async_runs_off_the_event_loop(self, service):
        """
        La recherche semantique appelait generate_embedding depuis une
        coroutine : la boucle etait gelee pour l'aller-retour reseau, le
        time.sleep du backoff et les E/S psycopg2 du cache.
        """
        import threading

        loop_thread = threading.get_ident()
        seen = {}

        original = service._produire

        def _spy(*args, **kwargs):
            seen["thread"] = threading.get_ident()
            return original(*args, **kwargs)

        service._produire = _spy

        embedding = await service.generate_embedding_async("Une question")

        assert embedding.shape == (EmbeddingService.EMBEDDING_DIM,)
        assert seen["thread"] != loop_thread

    @pytest.mark.asyncio
    async def test_async_wrapper_defaults_to_query_task(self, service, recorder):
        """Son seul appelant encode une question, pas un document."""
        await service.generate_embedding_async("Une question")

        assert recorder["payloads"][-1]["input_type"] == "query"

    def test_batch_encodes_documents(self, service, recorder):
        """
        L'autre moitie de l'asymetrie de la recherche : une inversion encoderait
        les articles comme des questions, sans erreur.
        """
        service.generate_batch_embeddings(["Article premier", "Article 2"])

        assert recorder["payloads"][-1]["input_type"] == "document"


class TestRequestTimeout:
    """
    Le client Gemini doit imposer un delai maximal.

    Sans http_options, le client attend indefiniment. Observe en conditions
    reelles pendant l'ingestion du corpus : le processus est reste 40 minutes
    endormi sur une lecture de prise reseau, vivant, sans consommer d'UC.
    Aucune exception n'etant levee, la boucle de reprise du service ne se
    declenchait jamais — un blocage silencieux et sans fin.
    """

    def test_embedding_client_has_a_timeout(self):
        # Sans doublure : c'est le VRAI client Gemini qu'on inspecte. Sa
        # construction n'ouvre aucune connexion. Les delais de Voyage sont
        # verifies dans test_embedding_voyage.py.
        from app.core.config import settings
        from app.services.embedding_service import GeminiProvider

        service = EmbeddingService(use_cache=False, provider=GeminiProvider(api_key="x"))
        configured = service.client._api_client._http_options.timeout

        assert configured == settings.GEMINI_TIMEOUT_S * 1000  # millisecondes
        assert configured > 0

    def test_generation_client_has_a_timeout(self):
        from app.core.config import settings
        from app.services.gemini_service import GeminiService

        service = GeminiService()

        assert service.client._api_client._http_options.timeout == (
            settings.GEMINI_TIMEOUT_S * 1000
        )


class TestDailyQuota:
    """
    Un quota JOURNALIER ne se rejoue pas.

    Google renvoie 429 aussi bien pour un quota par minute que par jour, et
    suggere un retryDelay d'une trentaine de secondes dans les deux cas. Pour un
    quota journalier ce delai est trompeur : reessayer trois fois brule une
    minute avant d'echouer de toute facon, et le lot suivant recommence. Seul le
    quotaId permet de trancher.
    """

    def test_recognises_a_daily_quota(self):
        from app.services.embedding_service import _is_daily_quota_error

        error = Exception(
            "429 RESOURCE_EXHAUSTED {'quotaId': "
            "'EmbedContentRequestsPerDayPerUserPerProjectPerModel-FreeTier'}"
        )

        assert _is_daily_quota_error(error) is True

    def test_a_per_minute_quota_stays_retryable(self):
        from app.services.embedding_service import _is_daily_quota_error

        error = Exception(
            "429 RESOURCE_EXHAUSTED {'quotaId': 'EmbedContentRequestsPerMinutePerProject'}"
        )

        assert _is_daily_quota_error(error) is False

    def test_other_errors_are_not_quota(self):
        from app.services.embedding_service import _is_daily_quota_error

        assert _is_daily_quota_error(Exception("500 INTERNAL")) is False
        assert _is_daily_quota_error(Exception("401 UNAUTHENTICATED")) is False

    def test_batch_raises_immediately_without_retrying(self, monkeypatch):
        """Aucune tentative supplementaire : on leve au premier 429 journalier."""
        from app.services.embedding_service import GeminiProvider, QuotaExhaustedError

        service = EmbeddingService(use_cache=False, provider=GeminiProvider(api_key="x"))

        calls = {"n": 0}

        def _always_quota(**kwargs):
            calls["n"] += 1
            raise RuntimeError(
                "429 RESOURCE_EXHAUSTED {'quotaId': "
                "'EmbedContentRequestsPerDayPerUserPerProjectPerModel-FreeTier'}"
            )

        monkeypatch.setattr(service.client.models, "embed_content", _always_quota)
        monkeypatch.setattr(module.time, "sleep", lambda *_: None)

        with pytest.raises(QuotaExhaustedError):
            service.generate_batch_embeddings(["a", "b"])

        assert calls["n"] == 1, "un quota journalier ne doit pas etre rejoue"