jurix-api / tests /test_services /test_embedding_providers.py
rahim237cm's picture
Claude Opus 5.5
feat(embeddings): voyage-4-large remplace EmbeddingGemma (API Voyage, halfvec 1024)
57c8117
Raw History Blame Contribute Delete
10.7 kB
"""
Tests du contrat de fournisseur d'embeddings.
Le service delegue la production des vecteurs a un fournisseur interchangeable
et garde tout le reste. Ces tests verrouillent les quatre garanties qui
rendent l'echange sur :
- deux fournisseurs ne se servent JAMAIS leurs vecteurs par le cache, meme a
dimension egale — c'est le cas que la garde de dimension ne voit pas ;
- une dimension que le fournisseur ne sait pas produire est refusee a la
construction, pas au premier appel apres trois tentatives ;
- ce qu'un nouvel essai reproduirait n'est jamais rejoue, et une question
n'a droit qu'a un essai ;
- le service normalise et verifie, quel que soit ce que rend le fournisseur.
Aucun vrai modele, aucun appel reseau : les fournisseurs sont des doublures.
"""
import numpy as np
import pytest
from app.services import embedding_service as module
from app.services.embedding_service import (
EmbeddingDefinitiveError,
EmbeddingService,
EmbeddingServiceError,
GeminiProvider,
)
class _Fournisseur:
"""Fournisseur factice, configurable, qui compte ses appels."""
label = "Fournisseur de test"
model = "modele-de-test"
retryable = True
inter_batch_delay_s = 0.0
def __init__(self, name="test", native_dim=None, echec=None, norme=7.0):
self.name = name
self.native_dim = native_dim or EmbeddingService.EMBEDDING_DIM
self.echec = echec
self.norme = norme
self.appels = 0
@property
def fingerprint(self):
return f"{self.name}|{self.model}"
def embed(self, texts, task_type, dim):
self.appels += 1
if self.echec:
raise self.echec
rng = np.random.default_rng(3)
# Vecteurs NON unitaires : c'est au service de normaliser.
return [(rng.random(dim) * self.norme).astype(np.float32) for _ in texts]
def _service(fournisseur):
return EmbeddingService(use_cache=False, provider=fournisseur)
class TestEmpreinteDansLaCle:
def test_deux_fournisseurs_a_dimension_egale_ont_des_cles_distinctes(self):
"""
Le cas que la garde de dimension ne voit pas : meme texte, meme
dimension, meme tache, deux modeles. Sans l'empreinte dans la cle, le
vecteur de l'un serait resservi a l'autre pendant sept jours.
"""
a = _service(_Fournisseur(name="a"))
b = _service(_Fournisseur(name="b"))
cle_a = a._cache_key("Article premier", EmbeddingService.TASK_DOCUMENT)
cle_b = b._cache_key("Article premier", EmbeddingService.TASK_DOCUMENT)
assert cle_a != cle_b
def test_meme_fournisseur_meme_cle(self):
a = _service(_Fournisseur(name="a"))
a2 = _service(_Fournisseur(name="a"))
assert a._cache_key("x", EmbeddingService.TASK_DOCUMENT) == a2._cache_key(
"x", EmbeddingService.TASK_DOCUMENT
)
def test_la_cle_lit_l_empreinte_de_l_instance(self):
"""Pas une constante de classe figee a l'import."""
f = _Fournisseur(name="avant")
s = _service(f)
avant = s._cache_key("x", EmbeddingService.TASK_DOCUMENT)
f.name = "apres"
assert s._cache_key("x", EmbeddingService.TASK_DOCUMENT) != avant
def test_empreinte_gemini_porte_le_modele(self, monkeypatch):
monkeypatch.setattr(module.genai, "Client", lambda *a, **k: object())
assert GeminiProvider(api_key="factice").fingerprint == (
f"gemini|{module.settings.GEMINI_EMBEDDING_MODEL}"
)
class TestDimensionNative:
def test_dimension_trop_grande_refusee_a_la_construction(self):
"""
Sans ce controle, l'erreur n'apparait qu'au premier appel, apres trois
tentatives, et la recherche hybride l'avale sans bruit.
"""
trop_petit = _Fournisseur(native_dim=EmbeddingService.EMBEDDING_DIM - 1)
with pytest.raises(EmbeddingServiceError, match="dimension native"):
_service(trop_petit)
def test_dimension_egale_a_la_native_acceptee(self):
_service(_Fournisseur(native_dim=EmbeddingService.EMBEDDING_DIM))
def test_dimension_hors_des_dimensions_permises_refusee(self):
"""
Voyage n'accepte que 256, 512, 1024 et 2048 : une dimension sous la
native mais hors liste n'echouerait qu'au premier appel, en HTTP 400,
que la recherche hybride avalerait.
"""
f = _Fournisseur(native_dim=2048)
f.dimensions_permises = (256, 512, 2048)
with pytest.raises(EmbeddingServiceError, match="permises"):
_service(f)
def test_dimension_permise_acceptee(self):
f = _Fournisseur(native_dim=2048)
f.dimensions_permises = (EmbeddingService.EMBEDDING_DIM,)
_service(f)
class TestLimiteDeTexte:
def test_la_limite_du_fournisseur_s_impose_a_l_instance(self):
f = _Fournisseur()
f.max_caracteres = 50
s = _service(f)
assert s.MAX_TEXT_LENGTH == 50
with pytest.raises(ValueError, match="trop long"):
s.generate_embedding("x" * 51)
def test_sans_limite_declaree_le_defaut_du_service(self):
assert _service(_Fournisseur()).MAX_TEXT_LENGTH == EmbeddingService.MAX_TEXT_LENGTH
def test_gemini_garde_sa_limite(self):
"""2 048 jetons de contexte chez gemini-embedding-001."""
assert GeminiProvider.max_caracteres == 10_000
class TestReprises:
def test_fournisseur_non_rejouable_echoue_au_premier_appel(self, monkeypatch):
"""
Un modele local qui echoue echouera pareil a la tentative suivante :
rejouer ne ferait que dormir avant d'echouer quand meme.
"""
dodos = []
monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s))
f = _Fournisseur(echec=RuntimeError("modele indisponible"))
f.retryable = False
with pytest.raises(EmbeddingServiceError):
_service(f).generate_embedding("Article premier")
assert f.appels == 1
assert dodos == []
def test_fournisseur_rejouable_est_rejoue(self, monkeypatch):
monkeypatch.setattr(module.time, "sleep", lambda s: None)
f = _Fournisseur(echec=RuntimeError("503 passager"))
with pytest.raises(EmbeddingServiceError):
_service(f).generate_embedding("Article premier")
assert f.appels == EmbeddingService.MAX_RETRIES
def test_une_erreur_definitive_n_est_pas_rejouee(self, monkeypatch):
"""Une cle refusee le sera encore : la relancer telle quelle."""
dodos = []
monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s))
f = _Fournisseur(echec=EmbeddingDefinitiveError("HTTP 401 : cle refusee"))
with pytest.raises(EmbeddingDefinitiveError):
_service(f).generate_embedding("Article premier")
with pytest.raises(EmbeddingDefinitiveError):
_service(f).generate_batch_embeddings(["a", "b"])
assert f.appels == 2
assert dodos == []
def test_une_question_n_a_qu_un_essai(self, monkeypatch):
"""
Pendant ce temps, l'utilisateur attend : un echec passager ne lui
coute que le volet semantique de sa recherche.
"""
dodos = []
monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s))
f = _Fournisseur(echec=RuntimeError("503 passager"))
with pytest.raises(EmbeddingServiceError):
_service(f).generate_embedding("Une question", task_type=EmbeddingService.TASK_QUERY)
assert f.appels == 1
assert dodos == []
def test_pas_de_pause_entre_lots_si_le_fournisseur_n_en_veut_pas(self, monkeypatch):
dodos = []
monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s))
f = _Fournisseur() # inter_batch_delay_s = 0.0
_service(f).generate_batch_embeddings(["a", "b", "c"], batch_size=1)
assert dodos == []
class TestLeServiceGardeSesControles:
def test_le_service_normalise_quel_que_soit_le_fournisseur(self):
vecteur = _service(_Fournisseur(norme=9.0)).generate_embedding("Article premier")
assert vecteur.shape == (EmbeddingService.EMBEDDING_DIM,)
assert abs(float(np.linalg.norm(vecteur)) - 1.0) < 1e-5
def test_reponse_incomplete_detectee_par_le_service(self):
class _Court(_Fournisseur):
def embed(self, texts, task_type, dim):
return super().embed(texts[:-1], task_type, dim)
with pytest.raises(EmbeddingServiceError, match="incomplète"):
_service(_Court()).generate_batch_embeddings(["a", "b", "c"])
def test_le_fournisseur_injecte_est_celui_qui_sert(self):
f = _Fournisseur()
s = _service(f)
s.generate_embedding("Article premier")
assert s.provider is f
assert f.appels == 1
def test_health_check_decrit_le_fournisseur(self):
sante = _service(_Fournisseur()).health_check()
assert sante["provider"] == "Fournisseur de test"
assert sante["model"] == "modele-de-test"
class TestGeminiRefus:
"""
Une cle Gemini invalide arrive en 400 (API_KEY_INVALID) : elle doit
arreter un traitement par lots, pas faire sauter chaque lot apres trois
essais.
"""
@staticmethod
def _fournisseur(monkeypatch, erreur):
class _Modeles:
def embed_content(self, **kwargs):
raise erreur
class _Client:
def __init__(self, *a, **k):
self.models = _Modeles()
monkeypatch.setattr(module.genai, "Client", _Client)
return GeminiProvider(api_key="factice")
def test_une_cle_invalide_vise_la_configuration(self, monkeypatch):
from google.genai import errors
erreur = errors.ClientError(400, {"error": {
"code": 400, "message": "API key not valid.", "status": "INVALID_ARGUMENT",
"details": [{"reason": "API_KEY_INVALID"}],
}})
with pytest.raises(EmbeddingDefinitiveError) as refus:
self._fournisseur(monkeypatch, erreur).embed(["a"], EmbeddingService.TASK_DOCUMENT, 1024)
assert refus.value.code == 401
assert refus.value.vise_la_configuration
def test_un_429_reste_rejouable(self, monkeypatch):
"""Le quota par minute se rejoue ; _is_daily_quota_error lit son message."""
from google.genai import errors
erreur = errors.ClientError(429, {"error": {
"code": 429, "message": "Resource has been exhausted", "status": "RESOURCE_EXHAUSTED",
}})
with pytest.raises(errors.ClientError):
self._fournisseur(monkeypatch, erreur).embed(["a"], EmbeddingService.TASK_DOCUMENT, 1024)