SteGONZALEZ commited on
Commit
6d68c0d
·
1 Parent(s): fe0d439

commentaires dans les tests

Browse files
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(employee_id=1, turnover_probability=0.7, will_leave=True)
 
 
 
 
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
- ## Obligaoitre pour couvrir le coverage de la branche
87
- # tester que l'endpoint de prédiction par ID gère une exception inattendue et renvoie un HTTP 500.
88
  def test_predict_by_id_returns_500_on_unexpected_error(client, monkeypatch):
89
- # Force la branche "except Exception" -> HTTP 500
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
- # tester que l'endpoint de readiness vérifie la connexion à la DB et renvoie 503 si la table clean.ml_features_employees est manquante.
 
 
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() # "modèle chargé"
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, notamment pour simuler les processus de l'API et du dashboard.
 
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, qui correspond aux features attendues par le modèle de prédiction.
 
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, et time.sleep pour éviter de faire attendre le test.
 
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
- # On recharge le module main pour exécuter la fonction main() avec nos mocks en place, ce qui permet de
24
- # tester le comportement de lancement et d'arrêt des processus.
 
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, ce qui correspond au comportement attendu.
 
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, ce qui est important pour éviter de laisser des processus zombies.
 
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)