Spaces:
Sleeping
Sleeping
Commit ·
6d68c0d
1
Parent(s): fe0d439
commentaires dans les tests
Browse files- service/technova_service.py +1 -3
- tests/conftest.py +8 -2
- tests/test_api.py +40 -8
- tests/test_database.py +12 -1
- tests/test_main.py +28 -7
- tests/test_security.py +7 -0
- tests/test_technova_service.py +17 -3
service/technova_service.py
CHANGED
|
@@ -1,5 +1,3 @@
|
|
| 1 |
-
from __future__ import annotations
|
| 2 |
-
|
| 3 |
"""
|
| 4 |
service.technova_service
|
| 5 |
|
|
@@ -42,6 +40,7 @@ Exemples
|
|
| 42 |
- MODE debug / scoring direct :
|
| 43 |
predict_from_payload(request)
|
| 44 |
"""
|
|
|
|
| 45 |
|
| 46 |
import json
|
| 47 |
import os
|
|
@@ -97,7 +96,6 @@ def _get_artifact_path(artifacts_dir: Path, filename: str) -> str:
|
|
| 97 |
repo_type="model",
|
| 98 |
)
|
| 99 |
|
| 100 |
-
|
| 101 |
# Service encapsulant la logique de chargement du modèle, de préparation des données et de prédiction.
|
| 102 |
class TechNovaService:
|
| 103 |
"""
|
|
|
|
|
|
|
|
|
|
| 1 |
"""
|
| 2 |
service.technova_service
|
| 3 |
|
|
|
|
| 40 |
- MODE debug / scoring direct :
|
| 41 |
predict_from_payload(request)
|
| 42 |
"""
|
| 43 |
+
from __future__ import annotations
|
| 44 |
|
| 45 |
import json
|
| 46 |
import os
|
|
|
|
| 96 |
repo_type="model",
|
| 97 |
)
|
| 98 |
|
|
|
|
| 99 |
# Service encapsulant la logique de chargement du modèle, de préparation des données et de prédiction.
|
| 100 |
class TechNovaService:
|
| 101 |
"""
|
tests/conftest.py
CHANGED
|
@@ -10,8 +10,14 @@ from app.database import get_db
|
|
| 10 |
from app.models import Base
|
| 11 |
from app.security import verify_api_key
|
| 12 |
|
|
|
|
|
|
|
|
|
|
| 13 |
os.environ.setdefault("API_KEY", "ci-test-key")
|
| 14 |
|
|
|
|
|
|
|
|
|
|
| 15 |
TEST_DB_URL = "sqlite+pysqlite:///:memory:"
|
| 16 |
|
| 17 |
# On définit une fixture pour créer une base de données en mémoire pour les tests,
|
|
@@ -27,7 +33,7 @@ def engine():
|
|
| 27 |
.execution_options(schema_translate_map={"raw": None, "clean": None, "app": None})
|
| 28 |
)
|
| 29 |
Base.metadata.create_all(eng)
|
| 30 |
-
yield eng
|
| 31 |
eng.dispose()
|
| 32 |
|
| 33 |
# On définit une fonction pour générer un payload d'exemple,
|
|
@@ -37,7 +43,7 @@ def db(engine):
|
|
| 37 |
SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
|
| 38 |
session = SessionLocal()
|
| 39 |
try:
|
| 40 |
-
yield session
|
| 41 |
finally:
|
| 42 |
session.close()
|
| 43 |
|
|
|
|
| 10 |
from app.models import Base
|
| 11 |
from app.security import verify_api_key
|
| 12 |
|
| 13 |
+
#donne une valeur par défaut à la variable d'environnement API_KEY pour les tests,
|
| 14 |
+
#ce qui permet de s'assurer que les tests peuvent s'exécuter même si la variable
|
| 15 |
+
# d'environnement n'est pas définie dans l'environnement de test.
|
| 16 |
os.environ.setdefault("API_KEY", "ci-test-key")
|
| 17 |
|
| 18 |
+
# On définit une URL de base de données pour les tests, en utilisant une base de données SQLite en mémoire,
|
| 19 |
+
# ce qui permet d'avoir une base de données rapide et isolée pour les tests,
|
| 20 |
+
# sans nécessiter de configuration supplémentaire.
|
| 21 |
TEST_DB_URL = "sqlite+pysqlite:///:memory:"
|
| 22 |
|
| 23 |
# On définit une fixture pour créer une base de données en mémoire pour les tests,
|
|
|
|
| 33 |
.execution_options(schema_translate_map={"raw": None, "clean": None, "app": None})
|
| 34 |
)
|
| 35 |
Base.metadata.create_all(eng)
|
| 36 |
+
yield eng # On utilise yield pour permettre aux tests d'utiliser la base de données pendant leur exécution
|
| 37 |
eng.dispose()
|
| 38 |
|
| 39 |
# On définit une fonction pour générer un payload d'exemple,
|
|
|
|
| 43 |
SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
|
| 44 |
session = SessionLocal()
|
| 45 |
try:
|
| 46 |
+
yield session # On utilise yield pour permettre aux tests d'utiliser la session de base de données pendant leur exécution
|
| 47 |
finally:
|
| 48 |
session.close()
|
| 49 |
|
tests/test_api.py
CHANGED
|
@@ -1,4 +1,3 @@
|
|
| 1 |
-
# tests/test_api.py
|
| 2 |
import pytest
|
| 3 |
import numpy as np
|
| 4 |
|
|
@@ -6,6 +5,8 @@ from domain.domain import ModelResponse
|
|
| 6 |
from service.technova_service import TechNovaService
|
| 7 |
|
| 8 |
|
|
|
|
|
|
|
| 9 |
def sample_payload():
|
| 10 |
return {
|
| 11 |
"note_evaluation_precedente": 3,
|
|
@@ -43,50 +44,76 @@ def sample_payload():
|
|
| 43 |
}
|
| 44 |
|
| 45 |
|
|
|
|
|
|
|
| 46 |
@pytest.fixture(autouse=True)
|
| 47 |
def patch_service(monkeypatch):
|
|
|
|
| 48 |
class FakeModel:
|
| 49 |
def predict_proba(self, X):
|
|
|
|
| 50 |
return np.array([[0.2, 0.8]])
|
| 51 |
|
|
|
|
| 52 |
def fake_init(self):
|
| 53 |
self.threshold = 0.5
|
| 54 |
self.feature_columns = list(sample_payload().keys())
|
| 55 |
self.model = FakeModel()
|
| 56 |
|
|
|
|
|
|
|
|
|
|
| 57 |
def fake_predict_from_clean(self, db, employee_id: int):
|
| 58 |
if employee_id == 1:
|
| 59 |
-
return ModelResponse(
|
|
|
|
|
|
|
|
|
|
|
|
|
| 60 |
raise ValueError("not found")
|
| 61 |
|
|
|
|
| 62 |
monkeypatch.setattr(TechNovaService, "__init__", fake_init)
|
| 63 |
monkeypatch.setattr(TechNovaService, "predict_from_clean", fake_predict_from_clean)
|
| 64 |
|
|
|
|
|
|
|
| 65 |
def test_health(client):
|
| 66 |
r = client.get("/health")
|
| 67 |
assert r.status_code == 200
|
| 68 |
|
|
|
|
|
|
|
| 69 |
def test_predict_by_features_ok(client):
|
| 70 |
r = client.post("/predict/by-features", json=sample_payload())
|
| 71 |
assert r.status_code == 200, r.text
|
| 72 |
data = r.json()
|
|
|
|
| 73 |
assert "turnover_probability" in data
|
| 74 |
assert "will_leave" in data
|
| 75 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 76 |
def test_predict_by_id_200_and_404(client):
|
| 77 |
assert client.post("/predict/by-id/1").status_code == 200
|
| 78 |
assert client.post("/predict/by-id/2").status_code == 404
|
| 79 |
|
|
|
|
|
|
|
| 80 |
def test_latest_predictions_returns_list(client):
|
|
|
|
| 81 |
client.post("/predict/by-features", json=sample_payload())
|
|
|
|
| 82 |
r = client.get("/predictions/latest", params={"limit": 3})
|
| 83 |
assert r.status_code == 200, r.text
|
| 84 |
assert isinstance(r.json(), list)
|
| 85 |
|
| 86 |
-
|
| 87 |
-
#
|
| 88 |
def test_predict_by_id_returns_500_on_unexpected_error(client, monkeypatch):
|
| 89 |
-
# Force
|
| 90 |
def boom(self, db, employee_id: int):
|
| 91 |
raise Exception("boom")
|
| 92 |
|
|
@@ -95,14 +122,17 @@ def test_predict_by_id_returns_500_on_unexpected_error(client, monkeypatch):
|
|
| 95 |
r = client.post("/predict/by-id/1")
|
| 96 |
assert r.status_code == 500, r.text
|
| 97 |
|
| 98 |
-
|
|
|
|
|
|
|
| 99 |
def test_ready_returns_503_when_clean_table_missing(client, monkeypatch):
|
| 100 |
-
# Ici on override directement les dépendances FastAPI (get_db, get_service)
|
| 101 |
import app.api as api
|
| 102 |
|
|
|
|
| 103 |
class FakeService:
|
| 104 |
-
model = object()
|
| 105 |
|
|
|
|
| 106 |
class FakeDB:
|
| 107 |
def execute(self, stmt, *_a, **_kw):
|
| 108 |
s = str(stmt)
|
|
@@ -116,6 +146,7 @@ def test_ready_returns_503_when_clean_table_missing(client, monkeypatch):
|
|
| 116 |
def fake_get_db():
|
| 117 |
yield FakeDB()
|
| 118 |
|
|
|
|
| 119 |
api.app.dependency_overrides[api.get_service] = fake_get_service
|
| 120 |
api.app.dependency_overrides[api.get_db] = fake_get_db
|
| 121 |
|
|
@@ -124,4 +155,5 @@ def test_ready_returns_503_when_clean_table_missing(client, monkeypatch):
|
|
| 124 |
assert r.status_code == 503, r.text
|
| 125 |
assert "Clean table not ready" in r.text
|
| 126 |
finally:
|
|
|
|
| 127 |
api.app.dependency_overrides.clear()
|
|
|
|
|
|
|
| 1 |
import pytest
|
| 2 |
import numpy as np
|
| 3 |
|
|
|
|
| 5 |
from service.technova_service import TechNovaService
|
| 6 |
|
| 7 |
|
| 8 |
+
# Payload d’exemple complet correspondant aux features attendues par l’API
|
| 9 |
+
# Il est réutilisé dans plusieurs tests pour éviter les duplications
|
| 10 |
def sample_payload():
|
| 11 |
return {
|
| 12 |
"note_evaluation_precedente": 3,
|
|
|
|
| 44 |
}
|
| 45 |
|
| 46 |
|
| 47 |
+
# Fixture appliquée automatiquement à tous les tests du fichier
|
| 48 |
+
# Elle permet de remplacer le vrai service de prédiction par une version contrôlée
|
| 49 |
@pytest.fixture(autouse=True)
|
| 50 |
def patch_service(monkeypatch):
|
| 51 |
+
# Faux modèle pour éviter de charger un vrai modèle ML
|
| 52 |
class FakeModel:
|
| 53 |
def predict_proba(self, X):
|
| 54 |
+
# Retourne toujours la même probabilité pour rendre les tests déterministes
|
| 55 |
return np.array([[0.2, 0.8]])
|
| 56 |
|
| 57 |
+
# Faux __init__ pour éviter toute logique lourde (chargement joblib, fichiers, etc.)
|
| 58 |
def fake_init(self):
|
| 59 |
self.threshold = 0.5
|
| 60 |
self.feature_columns = list(sample_payload().keys())
|
| 61 |
self.model = FakeModel()
|
| 62 |
|
| 63 |
+
# Faux comportement pour la prédiction par ID
|
| 64 |
+
# ID = 1 -> prédiction valide
|
| 65 |
+
# autre ID -> erreur "not found"
|
| 66 |
def fake_predict_from_clean(self, db, employee_id: int):
|
| 67 |
if employee_id == 1:
|
| 68 |
+
return ModelResponse(
|
| 69 |
+
employee_id=1,
|
| 70 |
+
turnover_probability=0.7,
|
| 71 |
+
will_leave=True
|
| 72 |
+
)
|
| 73 |
raise ValueError("not found")
|
| 74 |
|
| 75 |
+
# Application des patches sur le service réel
|
| 76 |
monkeypatch.setattr(TechNovaService, "__init__", fake_init)
|
| 77 |
monkeypatch.setattr(TechNovaService, "predict_from_clean", fake_predict_from_clean)
|
| 78 |
|
| 79 |
+
|
| 80 |
+
# Test simple de l’endpoint de santé
|
| 81 |
def test_health(client):
|
| 82 |
r = client.get("/health")
|
| 83 |
assert r.status_code == 200
|
| 84 |
|
| 85 |
+
|
| 86 |
+
# Test de l’endpoint de prédiction à partir des features
|
| 87 |
def test_predict_by_features_ok(client):
|
| 88 |
r = client.post("/predict/by-features", json=sample_payload())
|
| 89 |
assert r.status_code == 200, r.text
|
| 90 |
data = r.json()
|
| 91 |
+
# Vérifie la présence des champs attendus dans la réponse
|
| 92 |
assert "turnover_probability" in data
|
| 93 |
assert "will_leave" in data
|
| 94 |
|
| 95 |
+
|
| 96 |
+
# Test de la prédiction par ID :
|
| 97 |
+
# - ID existant -> 200
|
| 98 |
+
# - ID inexistant -> 404
|
| 99 |
def test_predict_by_id_200_and_404(client):
|
| 100 |
assert client.post("/predict/by-id/1").status_code == 200
|
| 101 |
assert client.post("/predict/by-id/2").status_code == 404
|
| 102 |
|
| 103 |
+
|
| 104 |
+
# Test de l’endpoint qui retourne les dernières prédictions
|
| 105 |
def test_latest_predictions_returns_list(client):
|
| 106 |
+
# On crée d’abord une prédiction
|
| 107 |
client.post("/predict/by-features", json=sample_payload())
|
| 108 |
+
# Puis on vérifie que l’endpoint retourne bien une liste
|
| 109 |
r = client.get("/predictions/latest", params={"limit": 3})
|
| 110 |
assert r.status_code == 200, r.text
|
| 111 |
assert isinstance(r.json(), list)
|
| 112 |
|
| 113 |
+
|
| 114 |
+
# Test destiné à couvrir la branche d’erreur inattendue (HTTP 500)
|
| 115 |
def test_predict_by_id_returns_500_on_unexpected_error(client, monkeypatch):
|
| 116 |
+
# Force une exception non prévue dans le service
|
| 117 |
def boom(self, db, employee_id: int):
|
| 118 |
raise Exception("boom")
|
| 119 |
|
|
|
|
| 122 |
r = client.post("/predict/by-id/1")
|
| 123 |
assert r.status_code == 500, r.text
|
| 124 |
|
| 125 |
+
|
| 126 |
+
# Test de l’endpoint de readiness :
|
| 127 |
+
# il doit renvoyer 503 si la table clean.ml_features_employees est absente
|
| 128 |
def test_ready_returns_503_when_clean_table_missing(client, monkeypatch):
|
|
|
|
| 129 |
import app.api as api
|
| 130 |
|
| 131 |
+
# Faux service indiquant que le modèle est chargé
|
| 132 |
class FakeService:
|
| 133 |
+
model = object()
|
| 134 |
|
| 135 |
+
# Faux accès base de données simulant l’absence de la table clean
|
| 136 |
class FakeDB:
|
| 137 |
def execute(self, stmt, *_a, **_kw):
|
| 138 |
s = str(stmt)
|
|
|
|
| 146 |
def fake_get_db():
|
| 147 |
yield FakeDB()
|
| 148 |
|
| 149 |
+
# Override des dépendances FastAPI pour le test
|
| 150 |
api.app.dependency_overrides[api.get_service] = fake_get_service
|
| 151 |
api.app.dependency_overrides[api.get_db] = fake_get_db
|
| 152 |
|
|
|
|
| 155 |
assert r.status_code == 503, r.text
|
| 156 |
assert "Clean table not ready" in r.text
|
| 157 |
finally:
|
| 158 |
+
# Nettoyage des overrides pour ne pas impacter les autres tests
|
| 159 |
api.app.dependency_overrides.clear()
|
tests/test_database.py
CHANGED
|
@@ -1,3 +1,12 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
import importlib
|
| 2 |
import sys
|
| 3 |
|
|
@@ -8,7 +17,9 @@ def reload_database_module(monkeypatch, database_url: str | None):
|
|
| 8 |
monkeypatch.delenv("DATABASE_URL", raising=False)
|
| 9 |
else:
|
| 10 |
monkeypatch.setenv("DATABASE_URL", database_url)
|
| 11 |
-
|
|
|
|
|
|
|
| 12 |
sys.modules.pop("app.database", None)
|
| 13 |
import app.database # noqa: F401
|
| 14 |
return importlib.reload(app.database)
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Il y a 2 tests :
|
| 3 |
+
|
| 4 |
+
Vérifier que si DATABASE_URL n’est pas défini, ton module app.database utilise une URL SQLite par défaut.
|
| 5 |
+
|
| 6 |
+
Vérifier que get_db() ferme bien la session (appel à close()), même quand on utilise un faux objet.
|
| 7 |
+
|
| 8 |
+
"""
|
| 9 |
+
|
| 10 |
import importlib
|
| 11 |
import sys
|
| 12 |
|
|
|
|
| 17 |
monkeypatch.delenv("DATABASE_URL", raising=False)
|
| 18 |
else:
|
| 19 |
monkeypatch.setenv("DATABASE_URL", database_url)
|
| 20 |
+
|
| 21 |
+
# On supprime le module de sys.modules pour forcer son rechargement, ce qui permet de s'assurer
|
| 22 |
+
# que les changements d'environnement sont pris en compte lors de l'importation du module.
|
| 23 |
sys.modules.pop("app.database", None)
|
| 24 |
import app.database # noqa: F401
|
| 25 |
return importlib.reload(app.database)
|
tests/test_main.py
CHANGED
|
@@ -1,14 +1,31 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
import importlib
|
| 2 |
import sys
|
| 3 |
from unittest.mock import MagicMock, patch
|
| 4 |
|
| 5 |
-
# On importe les éléments nécessaires pour tester le module main,
|
|
|
|
| 6 |
def reload_main():
|
|
|
|
| 7 |
sys.modules.pop("app.main", None)
|
|
|
|
| 8 |
import app.main # noqa
|
| 9 |
return importlib.reload(app.main)
|
| 10 |
|
| 11 |
-
# On définit une fonction pour générer un payload d'exemple,
|
|
|
|
| 12 |
def test_main_starts_api_and_dashboard_and_stops_dashboard_when_api_exits():
|
| 13 |
fake_api = MagicMock()
|
| 14 |
fake_dash = MagicMock()
|
|
@@ -17,16 +34,19 @@ def test_main_starts_api_and_dashboard_and_stops_dashboard_when_api_exits():
|
|
| 17 |
fake_api.poll.side_effect = [None, 0]
|
| 18 |
fake_dash.poll.return_value = None
|
| 19 |
|
| 20 |
-
# On patch subprocess.Popen pour retourner nos mocks,
|
|
|
|
| 21 |
with patch("app.main.subprocess.Popen") as popen_mock, patch("app.main.time.sleep") as sleep_mock:
|
| 22 |
popen_mock.side_effect = [fake_api, fake_dash]
|
| 23 |
-
|
| 24 |
-
#
|
|
|
|
| 25 |
main = reload_main()
|
| 26 |
main.main()
|
| 27 |
|
| 28 |
# On vérifie que les processus ont été lancés et que
|
| 29 |
-
# le dashboard a été arrêté quand l'API s'est arrêtée,
|
|
|
|
| 30 |
assert popen_mock.call_count == 2
|
| 31 |
fake_dash.terminate.assert_called_once()
|
| 32 |
fake_api.terminate.assert_not_called()
|
|
@@ -35,7 +55,8 @@ def test_main_starts_api_and_dashboard_and_stops_dashboard_when_api_exits():
|
|
| 35 |
assert sleep_mock.called
|
| 36 |
|
| 37 |
# On teste aussi que si on interrompt le programme avec un KeyboardInterrupt,
|
| 38 |
-
# les deux processus sont correctement terminés,
|
|
|
|
| 39 |
def test_main_handles_keyboard_interrupt_and_terminates_both():
|
| 40 |
fake_api = MagicMock()
|
| 41 |
fake_dash = MagicMock()
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
Il teste la fonction main() de app.main, qui :
|
| 3 |
+
|
| 4 |
+
lance deux processus (API + dashboard)
|
| 5 |
+
|
| 6 |
+
surveille leur état
|
| 7 |
+
|
| 8 |
+
arrête proprement les processus quand il faut
|
| 9 |
+
|
| 10 |
+
Sans jamais lancer de vrais processus
|
| 11 |
+
tout est simulé avec des mocks.
|
| 12 |
+
|
| 13 |
+
"""
|
| 14 |
import importlib
|
| 15 |
import sys
|
| 16 |
from unittest.mock import MagicMock, patch
|
| 17 |
|
| 18 |
+
# On importe les éléments nécessaires pour tester le module main,
|
| 19 |
+
# notamment pour simuler les processus de l'API et du dashboard.
|
| 20 |
def reload_main():
|
| 21 |
+
# oublie app.main pour pouvoir le recharger proprement,
|
| 22 |
sys.modules.pop("app.main", None)
|
| 23 |
+
# on importe à nouveau le module main, ce qui permet de réinitialiser son état pour chaque test
|
| 24 |
import app.main # noqa
|
| 25 |
return importlib.reload(app.main)
|
| 26 |
|
| 27 |
+
# On définit une fonction pour générer un payload d'exemple,
|
| 28 |
+
# qui correspond aux features attendues par le modèle de prédiction.
|
| 29 |
def test_main_starts_api_and_dashboard_and_stops_dashboard_when_api_exits():
|
| 30 |
fake_api = MagicMock()
|
| 31 |
fake_dash = MagicMock()
|
|
|
|
| 34 |
fake_api.poll.side_effect = [None, 0]
|
| 35 |
fake_dash.poll.return_value = None
|
| 36 |
|
| 37 |
+
# On patch subprocess.Popen pour retourner nos mocks,
|
| 38 |
+
# et time.sleep pour éviter de faire attendre le test.
|
| 39 |
with patch("app.main.subprocess.Popen") as popen_mock, patch("app.main.time.sleep") as sleep_mock:
|
| 40 |
popen_mock.side_effect = [fake_api, fake_dash]
|
| 41 |
+
|
| 42 |
+
# On recharge le module main pour exécuter la fonction main() avec nos mocks en place,
|
| 43 |
+
# ce qui permet de tester le comportement de lancement et d'arrêt des processus.
|
| 44 |
main = reload_main()
|
| 45 |
main.main()
|
| 46 |
|
| 47 |
# On vérifie que les processus ont été lancés et que
|
| 48 |
+
# le dashboard a été arrêté quand l'API s'est arrêtée,
|
| 49 |
+
# ce qui correspond au comportement attendu.
|
| 50 |
assert popen_mock.call_count == 2
|
| 51 |
fake_dash.terminate.assert_called_once()
|
| 52 |
fake_api.terminate.assert_not_called()
|
|
|
|
| 55 |
assert sleep_mock.called
|
| 56 |
|
| 57 |
# On teste aussi que si on interrompt le programme avec un KeyboardInterrupt,
|
| 58 |
+
# les deux processus sont correctement terminés,
|
| 59 |
+
# ce qui est important pour éviter de laisser des processus zombies.
|
| 60 |
def test_main_handles_keyboard_interrupt_and_terminates_both():
|
| 61 |
fake_api = MagicMock()
|
| 62 |
fake_dash = MagicMock()
|
tests/test_security.py
CHANGED
|
@@ -1,3 +1,10 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
import os
|
| 2 |
|
| 3 |
# on teste que l'accès à l'endpoint de santé nécessite une clé API valide.
|
|
|
|
| 1 |
+
"""
|
| 2 |
+
teste l’endpoint /health avec la sécurité activée.
|
| 3 |
+
|
| 4 |
+
TEST 1 — Accès REFUSÉ sans clé API
|
| 5 |
+
TEST 2 — Accès AUTORISÉ avec une clé API valide
|
| 6 |
+
|
| 7 |
+
"""
|
| 8 |
import os
|
| 9 |
|
| 10 |
# on teste que l'accès à l'endpoint de santé nécessite une clé API valide.
|
tests/test_technova_service.py
CHANGED
|
@@ -4,27 +4,34 @@ import numpy as np
|
|
| 4 |
from service.technova_service import TechNovaService
|
| 5 |
|
| 6 |
class FakeModel:
|
|
|
|
| 7 |
def __init__(self, p1=0.8):
|
| 8 |
self.p1 = float(p1)
|
| 9 |
|
|
|
|
| 10 |
def predict_proba(self, X):
|
| 11 |
return np.array([[1.0 - self.p1, self.p1]], dtype=float)
|
| 12 |
|
| 13 |
class FakeRequest:
|
|
|
|
| 14 |
def __init__(self, data):
|
| 15 |
self._data = data
|
| 16 |
|
|
|
|
| 17 |
def model_dump(self):
|
| 18 |
return self._data
|
| 19 |
|
| 20 |
def make_service(feature_columns, p1=0.8, threshold=0.5):
|
| 21 |
# instancie sans __init__ (pas de joblib / fichiers)
|
| 22 |
s = TechNovaService.__new__(TechNovaService)
|
|
|
|
| 23 |
s.model = FakeModel(p1=p1)
|
| 24 |
s.threshold = float(threshold)
|
| 25 |
s.feature_columns = list(feature_columns)
|
| 26 |
return s
|
| 27 |
|
|
|
|
|
|
|
| 28 |
def test_adapt_input_missing_feature_raises():
|
| 29 |
s = make_service(feature_columns=["age", "revenu_mensuel"])
|
| 30 |
|
|
@@ -33,6 +40,8 @@ def test_adapt_input_missing_feature_raises():
|
|
| 33 |
with pytest.raises(ValueError, match="Missing features"):
|
| 34 |
s.adapt_input(req)
|
| 35 |
|
|
|
|
|
|
|
| 36 |
def test_predict_from_payload_applies_threshold():
|
| 37 |
s = make_service(feature_columns=["age"], p1=0.8, threshold=0.5)
|
| 38 |
|
|
@@ -44,6 +53,8 @@ def test_predict_from_payload_applies_threshold():
|
|
| 44 |
assert resp.will_leave is True
|
| 45 |
assert resp.employee_id is None
|
| 46 |
|
|
|
|
|
|
|
| 47 |
class FakeDBNoRow:
|
| 48 |
def execute(self, *_a, **_kw):
|
| 49 |
class R:
|
|
@@ -53,7 +64,8 @@ class FakeDBNoRow:
|
|
| 53 |
return None
|
| 54 |
return R()
|
| 55 |
|
| 56 |
-
|
|
|
|
| 57 |
def test_adapt_input_extra_feature_raises():
|
| 58 |
s = make_service(feature_columns=["age", "revenu_mensuel"])
|
| 59 |
|
|
@@ -62,7 +74,8 @@ def test_adapt_input_extra_feature_raises():
|
|
| 62 |
with pytest.raises(ValueError, match="Unexpected features"):
|
| 63 |
s.adapt_input(req)
|
| 64 |
|
| 65 |
-
|
|
|
|
| 66 |
def test_predict_from_payload_below_threshold():
|
| 67 |
s = make_service(feature_columns=["age"], p1=0.2, threshold=0.5)
|
| 68 |
|
|
@@ -72,7 +85,8 @@ def test_predict_from_payload_below_threshold():
|
|
| 72 |
assert resp.turnover_probability == 0.2
|
| 73 |
assert resp.will_leave is False
|
| 74 |
|
| 75 |
-
|
|
|
|
| 76 |
def test_predict_from_clean_not_found_raises():
|
| 77 |
# couvre la branche "aucune ligne clean"
|
| 78 |
s = make_service(feature_columns=["age"], p1=0.8, threshold=0.5)
|
|
|
|
| 4 |
from service.technova_service import TechNovaService
|
| 5 |
|
| 6 |
class FakeModel:
|
| 7 |
+
# Un modèle factice qui retourne une probabilité fixe pour la classe positive (p1)
|
| 8 |
def __init__(self, p1=0.8):
|
| 9 |
self.p1 = float(p1)
|
| 10 |
|
| 11 |
+
# La méthode predict_proba doit retourner un tableau de shape (n_samples, n_classes) avec les probabilités pour chaque classe.
|
| 12 |
def predict_proba(self, X):
|
| 13 |
return np.array([[1.0 - self.p1, self.p1]], dtype=float)
|
| 14 |
|
| 15 |
class FakeRequest:
|
| 16 |
+
# Un objet factice pour simuler une requête avec un payload de données.
|
| 17 |
def __init__(self, data):
|
| 18 |
self._data = data
|
| 19 |
|
| 20 |
+
# La méthode json() simule la méthode d'une requête qui retourne les données du payload sous forme de dictionnaire.
|
| 21 |
def model_dump(self):
|
| 22 |
return self._data
|
| 23 |
|
| 24 |
def make_service(feature_columns, p1=0.8, threshold=0.5):
|
| 25 |
# instancie sans __init__ (pas de joblib / fichiers)
|
| 26 |
s = TechNovaService.__new__(TechNovaService)
|
| 27 |
+
# on configure manuellement les attributs nécessaires pour les tests, notamment le modèle factice, le seuil de décision et les colonnes de features attendues.
|
| 28 |
s.model = FakeModel(p1=p1)
|
| 29 |
s.threshold = float(threshold)
|
| 30 |
s.feature_columns = list(feature_columns)
|
| 31 |
return s
|
| 32 |
|
| 33 |
+
# On teste que si une feature attendue est manquante dans le payload, la méthode adapt_input lève une erreur,
|
| 34 |
+
# ce qui est important pour garantir que les données d'entrée sont complètes et conformes aux attentes du modèle.
|
| 35 |
def test_adapt_input_missing_feature_raises():
|
| 36 |
s = make_service(feature_columns=["age", "revenu_mensuel"])
|
| 37 |
|
|
|
|
| 40 |
with pytest.raises(ValueError, match="Missing features"):
|
| 41 |
s.adapt_input(req)
|
| 42 |
|
| 43 |
+
# On teste que la méthode predict_from_payload applique correctement le seuil de décision pour déterminer la classe prédite (will_leave),
|
| 44 |
+
# ce qui est crucial pour que les prédictions soient interprétables et exploitables par les utilisateurs de l'API.
|
| 45 |
def test_predict_from_payload_applies_threshold():
|
| 46 |
s = make_service(feature_columns=["age"], p1=0.8, threshold=0.5)
|
| 47 |
|
|
|
|
| 53 |
assert resp.will_leave is True
|
| 54 |
assert resp.employee_id is None
|
| 55 |
|
| 56 |
+
# On teste que si aucune ligne "clean" n'est trouvée pour un employee_id donné, la méthode predict_from_clean lève une erreur,
|
| 57 |
+
# ce qui est important pour éviter de faire des prédictions sur des données inexistantes ou incorrectes.
|
| 58 |
class FakeDBNoRow:
|
| 59 |
def execute(self, *_a, **_kw):
|
| 60 |
class R:
|
|
|
|
| 64 |
return None
|
| 65 |
return R()
|
| 66 |
|
| 67 |
+
# On teste que si des features inattendues sont présentes dans le payload, la méthode adapt_input lève une erreur,
|
| 68 |
+
# ce qui est important pour garantir que les données d'entrée sont conformes aux attentes du modèle et éviter des erreurs de traitement ou des prédictions incorrectes.
|
| 69 |
def test_adapt_input_extra_feature_raises():
|
| 70 |
s = make_service(feature_columns=["age", "revenu_mensuel"])
|
| 71 |
|
|
|
|
| 74 |
with pytest.raises(ValueError, match="Unexpected features"):
|
| 75 |
s.adapt_input(req)
|
| 76 |
|
| 77 |
+
# On teste que si la probabilité de départ est inférieure au seuil, la classe prédite (will_leave) est False,
|
| 78 |
+
# ce qui correspond au comportement attendu du modèle de prédiction et permet aux utilisateurs de comprendre les résultats de l'API.
|
| 79 |
def test_predict_from_payload_below_threshold():
|
| 80 |
s = make_service(feature_columns=["age"], p1=0.2, threshold=0.5)
|
| 81 |
|
|
|
|
| 85 |
assert resp.turnover_probability == 0.2
|
| 86 |
assert resp.will_leave is False
|
| 87 |
|
| 88 |
+
# On teste que si aucune ligne "clean" n'est trouvée pour un employee_id donné, la méthode predict_from_clean lève une erreur,
|
| 89 |
+
# ce qui est important pour éviter de faire des prédictions sur des données inexistantes ou incorrectes.
|
| 90 |
def test_predict_from_clean_not_found_raises():
|
| 91 |
# couvre la branche "aucune ligne clean"
|
| 92 |
s = make_service(feature_columns=["age"], p1=0.8, threshold=0.5)
|