feat(test) : add some fonctionals tets

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,27 @@
-from fastapi import APIRouter, HTTPException
-from config.db import SessionLocal       
+from fastapi import APIRouter, Depends, HTTPException
+from config.db import get_db       
 from models.ml import MLModel           
+from sqlalchemy.orm import Session
 
 router = APIRouter() 
 
 @router.get("/", tags=["models"])
-def list_ml_models():
+def list_ml_models(db: Session = Depends(get_db)):
     try:
-        with SessionLocal() as s:  
-            rows = (
-                s.query(MLModel)
-                 .order_by(MLModel.created_at.desc())
-                 .all()
-            )
-            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
-            ]
+        rows = (
+            db.query(MLModel)
+                .order_by(MLModel.created_at.desc())
+                .all()
+        )
+        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
+        ]
     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
 
-from config.db import SessionLocal
+from config.db import SessionLocal, 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,32 +13,31 @@ 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"])
 
-# (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)
+def batch_predict(payload: PredictRequest, db: Session = Depends(get_db)):
+    row = (
+        db.query(MLModel)
+          .filter(MLModel.name == payload.model_name)
+          .first()
+    )
 
+    # --- stocker les inputs
+    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)
@@ -53,16 +52,33 @@ 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)
+
+            print(objs[idx].id)
+            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,19 +1,10 @@
 
 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()
 

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[str] = 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,93 @@
+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 config.db import Base
+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,365 @@
+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 config.db import Base
+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
+