Merge pull request #37 from marintosti12/dev

.github/workflows/ci.yaml

@@ -28,6 +28,7 @@ jobs:
 
     env:
       DATABASE_URL: postgresql+asyncpg://ci:ci@localhost:5432/futurisys_ci
+      HF_TOKEN: ${{ secrets.HF_TOKEN }}
 
     steps:
       - name: Checkout

alembic/env.py

@@ -7,7 +7,8 @@ from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
 from sqlalchemy import pool
 
 from src.config.db import Base
-
+from dotenv import load_dotenv, find_dotenv
+load_dotenv(find_dotenv())
 # Alembic Config
 config = context.config
 if config.config_file_name is not None:

alembic/versions/24251a13df00_ml_outputs.py

@@ -0,0 +1,39 @@
+"""ml outputs
+
+Revision ID: 24251a13df00
+Revises: ecd589af543e
+Create Date: 2025-09-15 16:34:46.842373
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = '24251a13df00'
+down_revision: Union[str, Sequence[str], None] = 'ecd589af543e'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "ml_outputs",
+        sa.Column("id",  postgresql.UUID(as_uuid=True), primary_key=True,
+                  server_default=sa.text("gen_random_uuid()")),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False,
+                  server_default=sa.text("TIMEZONE('utc', now())")),
+        sa.Column("input_id",  postgresql.UUID(as_uuid=True), nullable=False),
+        sa.Column("prediction", sa.String(length=100), nullable=False),
+        sa.Column("prob", sa.Float(), nullable=True),
+        sa.Column("error", sa.String(length=500), nullable=True),
+        sa.ForeignKeyConstraint(["input_id"], ["ml_inputs.id"], ondelete="CASCADE"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("ml_outputs")
+

src/config/db.py

@@ -13,3 +13,10 @@ class Base(DeclarativeBase):
 
 engine = create_engine(settings.DATABASE_URL, echo=True, future=True)
 SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

src/controllers/home_controller.py

@@ -1,27 +1,88 @@
-from fastapi import APIRouter, HTTPException
-from config.db import SessionLocal       
-from models.ml import MLModel           
+from datetime import datetime
+from typing import List, Optional
 
-router = APIRouter() 
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
 
-@router.get("/", tags=["models"])
-def list_ml_models():
+from config.db import get_db
+from models.ml import MLModel
+
+router = APIRouter(tags=["Models"])
+
+
+class MLModelOut(BaseModel):
+    id: str = Field(..., description="Identifiant unique du modèle (UUID en chaîne).")
+    name: str = Field(..., description="Nom court du modèle.")
+    description: Optional[str] = Field(None, description="Description du modèle.")
+    created_at: Optional[datetime] = Field(
+        None, description="Date de création du modèle (UTC, ISO 8601)."
+    )
+    is_active: bool = Field(..., description="Modèle actif/inactif.")
+    model_config = {"json_schema_extra": {
+        "examples": [{
+            "id": "5b1c7b3a-0000-4000-8000-000000000002",
+            "name": "best_model",
+            "description": "XGB v1",
+            "created_at": "2025-09-15T10:11:03.950802+00:00",
+            "is_active": True
+        }]
+    }}
+
+
+@router.get(
+    "/",
+    response_model=List[MLModelOut],
+    status_code=status.HTTP_200_OK,
+    summary="Lister les modèles ML",
+    description=(
+        "Retourne la liste des modèles disponibles, triés du plus récent au plus ancien.\n\n"
+        "**Remarques**\n"
+        "- Les champs sont mappés depuis la table `ml_models`.\n"
+    ),
+    responses={
+        200: {
+            "description": "Liste des modèles.",
+            "content": {
+                "application/json": {
+                    "example": [
+                        {
+                            "id": "5b1c7b3a-0000-4000-8000-000000000002",
+                            "name": "best_model",
+                            "description": "XGB v1",
+                            "created_at": "2025-09-15T10:11:03.950802+00:00",
+                            "is_active": True
+                        },
+                        {
+                            "id": "5b1c7b3a-0000-4000-8000-000000000001",
+                            "name": "baseline",
+                            "description": "Baseline model",
+                            "created_at": "2025-09-15T10:11:03.950802+00:00",
+                            "is_active": True
+                        }
+                    ]
+                }
+            },
+        },
+        500: {"description": "Erreur serveur lors de la lecture des modèles."},
+    },
+)
+def list_ml_models(db: Session = Depends(get_db)) -> List[MLModelOut]:
     try:
-        with SessionLocal() as s:  
-            rows = (
-                s.query(MLModel)
-                 .order_by(MLModel.created_at.desc())
-                 .all()
+        rows = (
+            db.query(MLModel)
+              .order_by(MLModel.created_at.desc())
+              .all()
+        )
+        return [
+            MLModelOut(
+                id=str(r.id),
+                name=r.name,
+                description=r.description,
+                created_at=r.created_at,
+                is_active=r.is_active,
             )
-            return [
-                {
-                    "id": str(r.id),
-                    "name": r.name,
-                    "description": r.description,
-                    "created_at": r.created_at.isoformat() if r.created_at else None,
-                    "is_active": r.is_active,
-                }
-                for r in rows
-            ]
+            for r in rows
+        ]
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

src/controllers/predict_controller.py

@@ -1,11 +1,11 @@
-# src/controllers/predict_controller.py
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Body, status
 
-from config.db import SessionLocal
+from config.db import get_db
 from models.ml import MLModel 
 
 # Schemas
 from models.ml_inputs import MLInput
+from models.ml_output import MLOutput
 
 import pandas as pd
 from model_loader import load_model           
@@ -13,37 +13,119 @@ from features import compute_features
 from schemas.PredictItemResult import PredictItemResult
 from schemas.PredictResponse import PredictResponse
 from schemas.PredictRequest import PredictRequest
+from sqlalchemy.orm import Session
 
-router = APIRouter(prefix="/predict", tags=["inference"])
+router = APIRouter(prefix="/predict", tags=["Prédiction"])
 
-# (optionnel) mapping lisible des classes
 LABELS = {
     "0": "reste_dans_l_entreprise",
     "1": "parti_de_l_entreprise",
 }
 
-# --------- Route ----------
-@router.post("/", response_model=PredictResponse)
-def batch_predict(payload: PredictRequest):
-    with SessionLocal() as s:
-        row = (
-            s.query(MLModel)
-             .filter(MLModel.name == payload.model_name)
-             .first()
-        )
-
-        objs = [MLInput(**x.model_dump()) for x in payload.inputs]
-        s.add_all(objs)
-        s.commit()
+@router.post(
+    "/",
+    response_model=PredictResponse,
+    status_code=status.HTTP_200_OK,
+    summary="Prédire l’attrition d’un employé",
+    description=(
+        "Calcule la probabilité d’attrition pour chaque entrée fournie.\n\n"
+        "**Notes**\n"
+        "- `model_name` doit référencer un modèle *actif* en base (`MLModel`).\n"
+        "- Les données d’entrée sont persistées (`MLInput`) puis les sorties (`MLOutput`) sont enregistrées.\n"
+        "- En cas d’erreur de features ou de prédiction, la requête retourne **400**.\n"
+    ),
+    responses={
+        200: {"description": "Prédictions calculées avec succès."},
+        400: {"description": "Erreur pendant la préparation des features ou la prédiction."},
+        404: {"description": "Modèle introuvable ou inactif."},
+        500: {"description": "Impossible de charger le modèle/erreur serveur."},
+    },
+)
+def batch_predict(
+    payload: PredictRequest = Body(
+        ...,
+        examples={
+            "cas-minimal": {
+                "summary": "Exemple minimal",
+                "value": {
+                    "model_name": "best_model",
+                    "inputs": [
+                        {
+                            "id_employee": 123,
+                            "age": 35,
+                            "genre": "Homme",
+                            "revenu_mensuel": 4200
+                        }
+                    ],
+                },
+            },
+            "cas-complet": {
+                "summary": "Exemple complet",
+                "value": {
+                    "model_name": "best_model",
+                    "inputs": [
+                        {
+                            "id_employee": 123,
+                            "age": 35,
+                            "genre": "Homme",
+                            "revenu_mensuel": 4200,
+                            "statut_marital": "Célibataire",
+                            "departement": "Ventes",
+                            "poste": "Commercial",
+                            "nombre_experiences_precedentes": 2,
+                            "nombre_heures_travailless": 40,
+                            "annee_experience_totale": 5,
+                            "annees_dans_l_entreprise": 2,
+                            "annees_dans_le_poste_actuel": 1,
+                            "nombre_participation_pee": 1,
+                            "nb_formations_suivies": 3,
+                            "nombre_employee_sous_responsabilite": 0,
+                            "code_sondage": 7,
+                            "distance_domicile_travail": 12,
+                            "niveau_education": 3,
+                            "domaine_etude": "Marketing",
+                            "ayant_enfants": "Non",
+                            "frequence_deplacement": "Rarement",
+                            "annees_depuis_la_derniere_promotion": 0,
+                            "annes_sous_responsable_actuel": 1,
+                            "satisfaction_employee_environnement": 3,
+                            "note_evaluation_precedente": 4,
+                            "niveau_hierarchique_poste": 2,
+                            "satisfaction_employee_nature_travail": 3,
+                            "satisfaction_employee_equipe": 4,
+                            "satisfaction_employee_equilibre_pro_perso": 3,
+                            "eval_number": "E2",
+                            "note_evaluation_actuelle": 4,
+                            "heure_supplementaires": "Non",
+                            "augementation_salaire_precedente": 11
+                        }
+                    ],
+                },
+            },
+        },
+    ),
+    db: Session = Depends(get_db),
+):
+    row = (
+        db.query(MLModel)
+        .filter(MLModel.name == payload.model_name)
+        .first()
+    )
 
+    objs = [MLInput(**x.model_dump()) for x in payload.inputs]
+    db.add_all(objs)
+    db.commit()
 
-        if not row or getattr(row, "is_active", True) is False:
-            raise HTTPException(status_code=404, detail="Modèle introuvable ou inactif")
+    if not row or getattr(row, "is_active", True) is False:
+        raise HTTPException(status_code=404, detail="Modèle introuvable ou inactif")
 
     try:
         m = load_model(payload.model_name)
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Chargement du modèle '{payload.model_name}' impossible: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Chargement du modèle '{payload.model_name}' impossible: {e}",
+        )
 
     try:
         df = pd.DataFrame([x.model_dump() for x in payload.inputs])
@@ -53,16 +135,30 @@ def batch_predict(payload: PredictRequest):
 
         probas = m.predict_proba(X)
         classes = getattr(m, "classes_", None)
-        for p in probas:
+
+        for idx, p in enumerate(probas):
             i = int(p.argmax())
             key = str(classes[i]) if classes is not None else str(i)
             label = LABELS.get(key, key)
-            results.append(PredictItemResult(label=label, proba=float(p[i])))
+
+            pred = PredictItemResult(label=label, proba=float(p[i]))
+            results.append(pred)
+
+            db.add(
+                MLOutput(
+                    input_id=objs[idx].id,
+                    prediction=label,
+                    prob=float(p[i]),
+                )
+            )
+
+        db.commit()
 
     except Exception as e:
+        db.rollback()
         raise HTTPException(status_code=400, detail=f"Erreur pendant la prédiction: {e}")
 
     return PredictResponse(
         model_name=payload.model_name,
         results=results,
-    )
+    )

src/main.py

@@ -1,21 +1,17 @@
 
 from fastapi import FastAPI
 
-from config.db import SessionLocal
-
 
 from controllers.home_controller import router as ml_home_router
 from controllers.predict_controller import router as predict_router
 
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-        
 
-app = FastAPI()
+app = FastAPI(title="ML API",
+    description="""
+API d’inférence pour la prédiction d’attrition.
+- **/predict**: prédire un résultat selon le modèle
+- **/models**: lister les modèles disponibles
+""", version="1.0.0")
 
 app.include_router(ml_home_router)
 

src/models/ml_output.py

@@ -0,0 +1,31 @@
+# src/models/ml_output.py
+from __future__ import annotations
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import String, Float, DateTime, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.sql import func
+from sqlalchemy.dialects.postgresql import UUID
+
+from .base import Base 
+
+
+class MLOutput(Base):
+    __tablename__ = "ml_outputs"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+
+    input_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("ml_inputs.id", ondelete="CASCADE"), nullable=False
+    )
+
+    prediction: Mapped[str] = mapped_column(String(255), nullable=False)
+    prob: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    error: Mapped[Optional[str]] = mapped_column(String(500), nullable=True)

src/seeds/ml_models_seed.py

@@ -1,17 +1,15 @@
-# src/seeds/ml_models_seed.py
 import os
 from datetime import datetime, timezone
 from sqlalchemy import create_engine, text
 from sqlalchemy.orm import Session
 
-# (optionnel) charge .env automatiquement
 try:
     from dotenv import load_dotenv
     load_dotenv()
 except Exception:
     pass
 
-DATABASE_URL = os.environ["DATABASE_URL"]  # ex: postgresql+psycopg2://...
+DATABASE_URL = os.environ["DATABASE_URL"]  
 engine = create_engine(DATABASE_URL, future=True)
 
 UPSERT = text("""

tests/test_home.py

@@ -0,0 +1,92 @@
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from main import app
+from config.db import get_db
+
+from models.ml import MLModel
+
+import uuid
+from datetime import datetime, timezone
+
+
+def test_list_models_simple(tmp_path):
+    db_path = tmp_path / "testing.db"
+    engine = create_engine(
+        f"sqlite:///{db_path}",
+        connect_args={"check_same_thread": False},
+        future=True,
+    )
+    SQLSession = sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True)
+
+    MLModel.metadata.create_all(engine) 
+
+    session = SQLSession()
+
+    def get_db_override():
+        return session
+
+    app.dependency_overrides[get_db] = get_db_override
+
+    client = TestClient(app, raise_server_exceptions=False)
+
+    created = datetime(2025, 9, 15, 10, 11, 3, 950802, tzinfo=timezone.utc)
+    session.add_all(
+        [
+            MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000001"),
+                name="baseline",
+                description="Baseline model",
+                created_at=created,
+                is_active=True,
+            ),
+            MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000002"),
+                name="best_model",
+                description="XGB v1",
+                created_at=created,
+                is_active=True,
+            ),
+             MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000003"),
+                name="logistic_regression",
+                description="Logistic Regression",
+                created_at=created,
+                is_active=True,
+            ),
+        ]
+    )
+    session.commit()
+
+    resp = client.get("/")
+
+
+    app.dependency_overrides.clear()
+    session.close()
+
+    assert resp.status_code == 200
+    data = resp.json()
+    names = {row["name"] for row in data}
+    assert names == {"baseline", "best_model", 'logistic_regression'}
+
+
+def test_list_models_returns_500_when_db_fails():
+    class BrokenSession:
+        def query(self, *a, **kw):
+            raise RuntimeError("DB is down")
+
+    def get_db_override():
+        yield BrokenSession()
+
+    app.dependency_overrides[get_db] = get_db_override
+    client = TestClient(app, raise_server_exceptions=False)
+
+    resp = client.get("/")
+
+    app.dependency_overrides.clear()
+
+    assert resp.status_code == 500
+    body = resp.json()
+    assert "DB is down" in body["detail"]
+

tests/test_main.py

@@ -1,8 +0,0 @@
-from fastapi.testclient import TestClient
-
-from main import app
-
-client = TestClient(app)
-
-def test_root_ok():
-   assert True

tests/test_predict.py

@@ -0,0 +1,364 @@
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from main import app
+from config.db import get_db
+
+from models.ml import MLModel
+from models.ml_inputs import MLInput
+from models.ml_output import MLOutput
+
+import uuid
+from datetime import datetime, timezone
+
+
+def test_simple_predict(tmp_path):
+    db_path = tmp_path / "testing.db"
+    engine = create_engine(
+        f"sqlite:///{db_path}",
+        connect_args={"check_same_thread": False},
+        future=True,
+    )
+    SQLSession = sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True)
+
+    MLModel.metadata.create_all(engine) 
+    MLInput.metadata.create_all(engine) 
+    MLOutput.metadata.create_all(engine) 
+
+    session = SQLSession()
+
+    def get_db_override():
+        return session
+
+    
+    app.dependency_overrides[get_db] = get_db_override
+
+    client = TestClient(app, raise_server_exceptions=False)
+
+    created = datetime(2025, 9, 15, 10, 11, 3, 950802, tzinfo=timezone.utc)
+    session.add_all(
+        [
+            MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000001"),
+                name="baseline",
+                description="Baseline model",
+                created_at=created,
+                is_active=True,
+            ),
+            MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000002"),
+                name="best_model",
+                description="XGB v1",
+                created_at=created,
+                is_active=True,
+            ),
+             MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000003"),
+                name="logistic_regression",
+                description="Logistic Regression",
+                created_at=created,
+                is_active=True,
+            ),
+        ]
+    )
+    session.commit()
+
+
+    payload = {
+        "model_name": "best_model",
+        "inputs": [{
+            "id_employee": 123,
+            "age": 35,
+            "genre": "Homme",
+            "revenu_mensuel": 4200,
+            "statut_marital": "Célibataire",
+            "departement": "Ventes",
+            "poste": "Commercial",
+            "nombre_experiences_precedentes": 2,
+            "nombre_heures_travailless": 40,
+            "annee_experience_totale": 5,
+            "annees_dans_l_entreprise": 2,
+            "annees_dans_le_poste_actuel": 1,
+            "nombre_participation_pee": 1,
+            "nb_formations_suivies": 3,
+            "nombre_employee_sous_responsabilite": 0,
+            "code_sondage": 7,
+            "distance_domicile_travail": 12,
+            "niveau_education": 3,
+            "domaine_etude": "Marketing",
+            "ayant_enfants": "Non",
+            "frequence_deplacement": "Rarement",
+            "annees_depuis_la_derniere_promotion": 0,
+            "annes_sous_responsable_actuel": 1,
+            "satisfaction_employee_environnement": 3,
+            "note_evaluation_precedente": 4,
+            "niveau_hierarchique_poste": 2,
+            "satisfaction_employee_nature_travail": 3,
+            "satisfaction_employee_equipe": 4,
+            "satisfaction_employee_equilibre_pro_perso": 3,
+            "eval_number": "E2",
+            "note_evaluation_actuelle": 4,
+            "heure_supplementaires": "Non",
+            "augementation_salaire_precedente": 11
+        }]
+    }
+
+    
+    resp = client.post("/predict", json=payload)
+
+    print("STATUS:", resp.status_code)
+    print("BODY:", resp.text)
+
+    app.dependency_overrides.clear()
+    session.close()
+
+    assert resp.status_code == 200
+    data = resp.json()
+    assert data["model_name"] == "best_model"
+    assert isinstance(data["results"], list)
+    assert len(data["results"]) == 1
+
+    result = data["results"][0]
+    assert result["label"] == "reste_dans_l_entreprise"
+    assert isinstance(result["proba"], float)
+    assert 0 <= result["proba"] <= 1
+
+
+def test_not_found_model(tmp_path):
+    db_path = tmp_path / "testing.db"
+    engine = create_engine(
+        f"sqlite:///{db_path}",
+        connect_args={"check_same_thread": False},
+        future=True,
+    )
+    SQLSession = sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True)
+
+    MLModel.metadata.create_all(engine) 
+    MLInput.metadata.create_all(engine) 
+    MLOutput.metadata.create_all(engine) 
+
+    session = SQLSession()
+
+    def get_db_override():
+        return session
+
+    
+    app.dependency_overrides[get_db] = get_db_override
+
+    client = TestClient(app, raise_server_exceptions=False)
+
+    created = datetime(2025, 9, 15, 10, 11, 3, 950802, tzinfo=timezone.utc)
+    session.add_all(
+        [
+            MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000001"),
+                name="baseline",
+                description="Baseline model",
+                created_at=created,
+                is_active=True,
+            ),
+        ]
+    )
+    session.commit()
+
+
+    payload = {
+        "model_name": "best_model",
+        "inputs": [{
+            "id_employee": 123,
+            "age": 35,
+            "genre": "Homme",
+            "revenu_mensuel": 4200,
+            "statut_marital": "Célibataire",
+            "departement": "Ventes",
+            "poste": "Commercial",
+            "nombre_experiences_precedentes": 2,
+            "nombre_heures_travailless": 40,
+            "annee_experience_totale": 5,
+            "annees_dans_l_entreprise": 2,
+            "annees_dans_le_poste_actuel": 1,
+            "nombre_participation_pee": 1,
+            "nb_formations_suivies": 3,
+            "nombre_employee_sous_responsabilite": 0,
+            "code_sondage": 7,
+            "distance_domicile_travail": 12,
+            "niveau_education": 3,
+            "domaine_etude": "Marketing",
+            "ayant_enfants": "Non",
+            "frequence_deplacement": "Rarement",
+            "annees_depuis_la_derniere_promotion": 0,
+            "annes_sous_responsable_actuel": 1,
+            "satisfaction_employee_environnement": 3,
+            "note_evaluation_precedente": 4,
+            "niveau_hierarchique_poste": 2,
+            "satisfaction_employee_nature_travail": 3,
+            "satisfaction_employee_equipe": 4,
+            "satisfaction_employee_equilibre_pro_perso": 3,
+            "eval_number": "E2",
+            "note_evaluation_actuelle": 4,
+            "heure_supplementaires": "Non",
+            "augementation_salaire_precedente": 11
+        }]
+    }
+
+    
+    resp = client.post("/predict", json=payload)
+
+
+    app.dependency_overrides.clear()
+    session.close()
+
+    assert resp.status_code == 404
+    data = resp.json()
+    assert data["detail"] == "Modèle introuvable ou inactif"
+    
+
+def test_inactif_model(tmp_path):
+    db_path = tmp_path / "testing.db"
+    engine = create_engine(
+        f"sqlite:///{db_path}",
+        connect_args={"check_same_thread": False},
+        future=True,
+    )
+    SQLSession = sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True)
+
+    MLModel.metadata.create_all(engine) 
+    MLInput.metadata.create_all(engine) 
+    MLOutput.metadata.create_all(engine) 
+
+    session = SQLSession()
+
+    def get_db_override():
+        return session
+
+    
+    app.dependency_overrides[get_db] = get_db_override
+
+    client = TestClient(app, raise_server_exceptions=False)
+
+    created = datetime(2025, 9, 15, 10, 11, 3, 950802, tzinfo=timezone.utc)
+    session.add_all(
+        [
+            MLModel(
+                id=uuid.UUID("5b1c7b3a-0000-4000-8000-000000000001"),
+                name="baseline",
+                description="Baseline model",
+                created_at=created,
+                is_active=False,
+            ),
+        ]
+    )
+    session.commit()
+
+
+    payload = {
+        "model_name": "baseline",
+        "inputs": [{
+            "id_employee": 123,
+            "age": 35,
+            "genre": "Homme",
+            "revenu_mensuel": 4200,
+            "statut_marital": "Célibataire",
+            "departement": "Ventes",
+            "poste": "Commercial",
+            "nombre_experiences_precedentes": 2,
+            "nombre_heures_travailless": 40,
+            "annee_experience_totale": 5,
+            "annees_dans_l_entreprise": 2,
+            "annees_dans_le_poste_actuel": 1,
+            "nombre_participation_pee": 1,
+            "nb_formations_suivies": 3,
+            "nombre_employee_sous_responsabilite": 0,
+            "code_sondage": 7,
+            "distance_domicile_travail": 12,
+            "niveau_education": 3,
+            "domaine_etude": "Marketing",
+            "ayant_enfants": "Non",
+            "frequence_deplacement": "Rarement",
+            "annees_depuis_la_derniere_promotion": 0,
+            "annes_sous_responsable_actuel": 1,
+            "satisfaction_employee_environnement": 3,
+            "note_evaluation_precedente": 4,
+            "niveau_hierarchique_poste": 2,
+            "satisfaction_employee_nature_travail": 3,
+            "satisfaction_employee_equipe": 4,
+            "satisfaction_employee_equilibre_pro_perso": 3,
+            "eval_number": "E2",
+            "note_evaluation_actuelle": 4,
+            "heure_supplementaires": "Non",
+            "augementation_salaire_precedente": 11
+        }]
+    }
+
+    
+    resp = client.post("/predict", json=payload)
+
+    print("STATUS:", resp.status_code)
+    print("BODY:", resp.text)
+
+    app.dependency_overrides.clear()
+    session.close()
+
+    assert resp.status_code == 404
+    data = resp.json()
+    assert data["detail"] == "Modèle introuvable ou inactif"
+    
+
+def test_list_models_returns_500_when_db_fails():
+    class BrokenSession:
+        def query(self, *a, **kw):
+            raise RuntimeError("DB is down")
+
+    def get_db_override():
+        yield BrokenSession()
+
+    app.dependency_overrides[get_db] = get_db_override
+    client = TestClient(app, raise_server_exceptions=False)
+
+    payload = {
+        "model_name": "baseline",
+        "inputs": [{
+            "id_employee": 123,
+            "age": 35,
+            "genre": "Homme",
+            "revenu_mensuel": 4200,
+            "statut_marital": "Célibataire",
+            "departement": "Ventes",
+            "poste": "Commercial",
+            "nombre_experiences_precedentes": 2,
+            "nombre_heures_travailless": 40,
+            "annee_experience_totale": 5,
+            "annees_dans_l_entreprise": 2,
+            "annees_dans_le_poste_actuel": 1,
+            "nombre_participation_pee": 1,
+            "nb_formations_suivies": 3,
+            "nombre_employee_sous_responsabilite": 0,
+            "code_sondage": 7,
+            "distance_domicile_travail": 12,
+            "niveau_education": 3,
+            "domaine_etude": "Marketing",
+            "ayant_enfants": "Non",
+            "frequence_deplacement": "Rarement",
+            "annees_depuis_la_derniere_promotion": 0,
+            "annes_sous_responsable_actuel": 1,
+            "satisfaction_employee_environnement": 3,
+            "note_evaluation_precedente": 4,
+            "niveau_hierarchique_poste": 2,
+            "satisfaction_employee_nature_travail": 3,
+            "satisfaction_employee_equipe": 4,
+            "satisfaction_employee_equilibre_pro_perso": 3,
+            "eval_number": "E2",
+            "note_evaluation_actuelle": 4,
+            "heure_supplementaires": "Non",
+            "augementation_salaire_precedente": 11
+        }]
+    }
+
+    
+    resp = client.post("/predict", json=payload)
+
+    app.dependency_overrides.clear()
+
+    assert resp.status_code == 500
+