# Cheatsheet Jenkins UTILISANT Python - Guide Complet pour Débutants


[OK] QU'EST-CE QUE "JENKINS UTILISE PYTHON" ? (POUR DÉBUTANTS)

# === Différence FONDAMENTALE ===

# Il y a 2 façons TRÈS DIFFÉRENTES d'utiliser Python avec Jenkins:

# 1⃣ PYTHON-JENKINS (bibliothèque)
# = Python CONTRÔLE Jenkins de l'extérieur
# Vous écrivez un script Python sur VOTRE machine
# Ce script dit à Jenkins quoi faire via l'API
# Exemple: "Jenkins, crée-moi 10 jobs !"

# 2⃣ JENKINS UTILISE PYTHON (ce cheatsheet)
# = Jenkins EXÉCUTE du code Python
# Vous configurez Jenkins pour qu'il lance vos scripts Python
# Python s'exécute DANS les jobs Jenkins
# Exemple: Jenkins lance "pytest tests/" pour tester votre code


# === Analogie simple ===

# Imaginez Jenkins comme un ROBOT CUISINIER

# PYTHON-JENKINS (contrôle externe):
# Vous êtes le patron qui dit au robot:
# "Prépare la recette X, puis la recette Y"
# Vous donnez des ordres de l'extérieur

# JENKINS UTILISE PYTHON (ce cheatsheet):
# Le robot utilise Python comme INGRÉDIENT dans ses recettes
# Python fait PARTIE de ce que le robot cuisine
# Le robot exécute du code Python pour accomplir ses tâches


# === Pourquoi utiliser Python DANS Jenkins ? ===

# 1. TESTS AUTOMATIQUES
# Jenkins lance pytest pour tester votre code Python
# À chaque commit Git -> tests automatiques

# 2. SCRIPTS DE DÉPLOIEMENT
# Jenkins exécute vos scripts Python pour déployer votre app
# deploy.py s'exécute sur le serveur via Jenkins

# 3. TRAITEMENT DE DONNÉES
# Jenkins lance des scripts Python pour traiter des données
# Exemple: générer des rapports, nettoyer des fichiers

# 4. INTÉGRATION CONTINUE (CI)
# Jenkins vérifie automatiquement que votre code Python marche
# Lint -> Tests -> Build -> Deploy

# 5. AUTOMATISATION
# Jenkins exécute vos tâches Python selon un planning
# Exemple: backup.py tous les jours à 2h du matin


# === Comment ça marche concrètement ? ===

# ÉTAPE 1: Vous créez un projet Python
"""
mon-projet/
├── src/
│   └── app.py
├── tests/
│   └── test_app.py
├── requirements.txt
└── deploy.py
"""

# ÉTAPE 2: Vous créez un job Jenkins
# Le job contient des COMMANDES SHELL qui lancent Python

# ÉTAPE 3: Jenkins exécute ces commandes
# Exemple de commandes dans le job:
"""
# Installer dépendances
pip install -r requirements.txt

# Lancer tests
pytest tests/

# Si tests OK, déployer
python deploy.py
"""

# ÉTAPE 4: Jenkins vous montre les résultats
# [OK] Tests réussis ? Build vert
# [X] Tests échoués ? Build rouge, vous recevez une alerte


# === Cas d'usage RÉELS ===

# CAS 1: Application Web Django/Flask
# À chaque push sur GitHub:
# - Jenkins clone le code
# - Jenkins crée un venv Python
# - Jenkins installe les dépendances
# - Jenkins lance les tests (pytest)
# - Jenkins vérifie le code (flake8, black)
# - Si tout est OK, Jenkins déploie l'app

# CAS 2: Data Pipeline
# Tous les jours à 1h du matin:
# - Jenkins lance un script Python
# - Le script télécharge des données
# - Le script nettoie les données
# - Le script génère des rapports
# - Jenkins envoie les rapports par email

# CAS 3: Microservices
# À chaque commit:
# - Jenkins teste chaque microservice (Python)
# - Jenkins build les images Docker
# - Jenkins déploie sur Kubernetes
# - Jenkins vérifie que tout fonctionne

# CAS 4: Machine Learning
# Quand nouveau modèle:
# - Jenkins entraîne le modèle (Python + scikit-learn/TensorFlow)
# - Jenkins évalue les performances
# - Si métriques OK, Jenkins déploie le modèle
# - Jenkins surveille les prédictions en production


# === Qu'allez-vous apprendre dans ce cheatsheet ? ===

# 1. [OK] Configurer Python dans Jenkins
# 2. [OK] Créer des jobs qui exécutent du Python
# 3. [OK] Gérer les environnements virtuels (venv)
# 4. [OK] Lancer des tests Python (pytest, unittest)
# 5. [OK] Vérifier la qualité du code (flake8, black, mypy)
# 6. [OK] Gérer les dépendances (pip, requirements.txt)
# 7. [OK] Créer des pipelines Python complets (CI/CD)
# 8. [OK] Déployer des applications Python
# 9. [OK] Gérer les erreurs et déboguer
# 10. [OK] Optimiser les performances


# === Prérequis (ce qu'il faut savoir AVANT) ===

# Connaissances Python:
# [OK] Créer un fichier .py
# [OK] Installer des packages avec pip
# [OK] Utiliser un environnement virtuel (venv)
# [OK] Lancer un script Python

# Pas besoin de savoir:
# [X] Python-jenkins (bibliothèque)
# [X] API REST
# [X] Groovy (langage Jenkins)
# On va tout expliquer !


[OK] INSTALLATION & CONFIGURATION (DÉTAILLÉE)

# === ÉTAPE 1: Installer Jenkins ===

# Jenkins est un SERVEUR qui tourne en continu
# Il faut l'installer sur une machine (votre PC ou un serveur)

# MÉTHODE 1: Docker (LA PLUS SIMPLE) ***

# Pourquoi Docker ?
# - Installation en 1 commande
# - Pas de conflit avec votre système
# - Facile à supprimer
# - Même environnement partout

# Prérequis: Docker installé
# Windows/Mac: Docker Desktop
# Linux: sudo apt install docker.io

# Commande pour lancer Jenkins:
docker run -d \
  --name jenkins \
  -p 8080:8080 \
  -p 50000:50000 \
  -v jenkins_home:/var/jenkins_home \
  jenkins/jenkins:lts

# Explications ligne par ligne:
# docker run       : Lancer un conteneur
# -d               : Détaché (en arrière-plan)
# --name jenkins   : Nom du conteneur
# -p 8080:8080     : Port web de Jenkins
# -p 50000:50000   : Port pour les agents
# -v jenkins_home  : Sauvegarder les données
# jenkins/jenkins:lts : Image Jenkins LTS (stable)

# Attendre 30 secondes que Jenkins démarre
# Vérifier: docker ps
# Vous devez voir le conteneur "jenkins"

# Récupérer le mot de passe initial:
docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

# COPIER ce mot de passe (exemple: 3f5a8b2c9d4e7f1a2b3c4d5e6f7a8b9c)

# Ouvrir navigateur: http://localhost:8080
# Coller le mot de passe
# Cliquer "Install suggested plugins"
# Attendre installation (5-10 minutes)
# Créer votre compte admin


# MÉTHODE 2: Installation native Ubuntu/Debian

# Plus rapide mais plus complexe à configurer

# Étape 1: Ajouter le repository Jenkins
wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

# Étape 2: Installer Jenkins ET Java
sudo apt update
sudo apt install openjdk-11-jdk jenkins -y

# Étape 3: Démarrer Jenkins
sudo systemctl start jenkins
sudo systemctl enable jenkins  # Démarrage automatique

# Étape 4: Vérifier
sudo systemctl status jenkins
# Doit afficher "active (running)"

# Étape 5: Mot de passe initial
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

# Puis ouvrir http://localhost:8080


# MÉTHODE 3: macOS avec Homebrew

# Prérequis: Homebrew installé
# Installation:
brew install jenkins-lts

# Démarrer:
brew services start jenkins-lts

# Mot de passe:
cat /usr/local/var/jenkins_home/secrets/initialAdminPassword

# Ouvrir: http://localhost:8080


# === ÉTAPE 2: Configurer Python dans Jenkins ===

# Jenkins a besoin de TROUVER Python sur la machine

# VÉRIFIER que Python est installé:
# Ouvrir Jenkins > Manage Jenkins > System Information
# Chercher "Environment Variables"
# Vérifier PATH contient Python

# Si Python n'est pas trouvé:

# Solution 1: Installer Python globalement

# Ubuntu/Debian:
sudo apt update
sudo apt install python3 python3-pip python3-venv -y

# macOS:
brew install python3

# Windows:
# Télécharger depuis python.org
# [ATTENTION] COCHER "Add Python to PATH" !

# Vérifier installation:
python3 --version  # Doit afficher: Python 3.x.x
pip3 --version     # Doit afficher: pip xx.x.x


# Solution 2: Configurer PATH dans Jenkins

# Si Python installé mais Jenkins ne le trouve pas:

# Jenkins > Manage Jenkins > Configure System
# Section "Global properties"
# [OK] Cocher "Environment variables"
# Ajouter:
# Name: PATH
# Value: /usr/bin:/usr/local/bin:$PATH

# Ou spécifier le chemin EXACT de Python:
# Name: PYTHON_HOME
# Value: /usr/local/bin/python3


# Solution 3: Plugin Python (optionnel mais recommandé)

# Jenkins > Manage Jenkins > Manage Plugins
# Onglet "Available"
# Chercher "ShiningPanda"
# [OK] Cocher et installer
# Redémarrer Jenkins

# ShiningPanda permet de:
# - Gérer plusieurs versions de Python
# - Créer des venv automatiquement
# - Simplifier la config des jobs


# === ÉTAPE 3: Premier test ===

# Créer un job de test pour vérifier que Python marche

# Jenkins > New Item
# Nom: "test-python"
# Type: "Freestyle project"
# Cliquer OK

# Section "Build"
# Cliquer "Add build step"
# Choisir "Execute shell"

# Dans la zone de texte, écrire:
python3 --version
python3 -c "print('Hello from Jenkins!')"

# Cliquer "Save"

# Cliquer "Build Now"
# Attendre quelques secondes
# Cliquer sur le build #1
# Cliquer "Console Output"

# Vous devriez voir:
"""
Started by user admin
Running as SYSTEM
Building in workspace /var/jenkins_home/workspace/test-python
[test-python] $ /bin/sh -xe /tmp/jenkins1234.sh
+ python3 --version
Python 3.11.5
+ python3 -c 'print('\''Hello from Jenkins!'\'')'
Hello from Jenkins!
Finished: SUCCESS
"""

# [OK] Si vous voyez ça -> Python fonctionne dans Jenkins !
# [X] Si erreur -> Revoir la configuration Python


# === COMPRENDRE l'environnement Jenkins ===

# Quand Jenkins exécute du Python, il le fait dans un CONTEXTE spécifique:

# 1. WORKSPACE
# Chaque job a son propre dossier de travail
# Chemin: /var/jenkins_home/workspace/NOM_DU_JOB/
# C'est LÀ que vos fichiers sont

# 2. VARIABLES D'ENVIRONNEMENT
# Jenkins fournit des variables utiles:
# - $BUILD_NUMBER : Numéro du build
# - $JOB_NAME : Nom du job
# - $WORKSPACE : Chemin du workspace
# - $BUILD_URL : URL du build

# Exemple d'utilisation:
python3 -c "import os; print(f'Build #{os.getenv(\"BUILD_NUMBER\")}')"

# 3. UTILISATEUR
# Par défaut, Jenkins s'exécute comme utilisateur "jenkins"
# Permissions limitées pour la sécurité

# 4. ISOLATION
# Chaque build est ISOLÉ des autres
# Si vous créez des fichiers, ils restent dans le workspace
# Le prochain build repart d'un état propre


# === ÉTAPE 4: Configuration avancée ===

# Configurer Jenkins pour des projets Python sérieux

# 1. PLUGIN GIT (pour récupérer code depuis GitHub/GitLab)

# Jenkins > Manage Jenkins > Manage Plugins
# Onglet "Available"
# Chercher "Git plugin"
# Installer et redémarrer

# 2. PLUGIN PIPELINE (pour pipelines modernes)

# Chercher "Pipeline"
# Installer "Pipeline" et "Pipeline: Stage View"

# 3. PLUGIN HTML PUBLISHER (pour rapports de coverage)

# Chercher "HTML Publisher"
# Installer

# 4. PLUGIN WARNINGS NG (pour analyse de code)

# Chercher "Warnings Next Generation"
# Installer

# 5. PLUGIN JUNIT (pour résultats de tests)

# Normalement déjà installé
# Sinon, chercher "JUnit Plugin"


[OK] PREMIER JOB PYTHON (PAS À PAS)

# === Créer un job simple qui teste du code Python ===

# ÉTAPE 1: Créer un projet Python de test

# Sur VOTRE machine (pas dans Jenkins encore):

# Créer un dossier:
mkdir mon-projet-test
cd mon-projet-test

# Créer la structure:
"""
mon-projet-test/
├── src/
│   └── calculator.py
├── tests/
│   └── test_calculator.py
└── requirements.txt
"""

# Fichier: src/calculator.py
"""
def add(a, b):
    \"\"\"Additionner deux nombres\"\"\"
    return a + b

def subtract(a, b):
    \"\"\"Soustraire deux nombres\"\"\"
    return a - b

def multiply(a, b):
    \"\"\"Multiplier deux nombres\"\"\"
    return a * b

def divide(a, b):
    \"\"\"Diviser deux nombres\"\"\"
    if b == 0:
        raise ValueError("Division par zéro impossible")
    return a / b
"""

# Fichier: tests/test_calculator.py
"""
import sys
import os

# Ajouter src/ au path pour pouvoir importer calculator
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))

from calculator import add, subtract, multiply, divide
import pytest

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

def test_subtract():
    assert subtract(5, 3) == 2
    assert subtract(10, 10) == 0
    assert subtract(0, 5) == -5

def test_multiply():
    assert multiply(3, 4) == 12
    assert multiply(0, 100) == 0
    assert multiply(-2, 3) == -6

def test_divide():
    assert divide(10, 2) == 5
    assert divide(7, 2) == 3.5
    
def test_divide_by_zero():
    with pytest.raises(ValueError):
        divide(10, 0)
"""

# Fichier: requirements.txt
"""
pytest==7.4.0
"""

# Initialiser un repo Git:
git init
git add .
git commit -m "Initial commit"

# Pousser sur GitHub:
# (Créer un repo sur GitHub d'abord)
git remote add origin https://github.com/VOTRE_USERNAME/mon-projet-test.git
git push -u origin main


# ÉTAPE 2: Créer le job Jenkins

# Jenkins > New Item
# Nom: "mon-projet-test"
# Type: "Freestyle project"
# OK


# ÉTAPE 3: Configurer la source du code

# Section "Source Code Management"
# [BLANC] Cocher "Git"

# Repository URL: https://github.com/VOTRE_USERNAME/mon-projet-test.git
# Credentials: (laisser vide si repo public)

# Branch Specifier: */main
# (ou */master selon votre branche principale)


# ÉTAPE 4: Configurer le build

# Section "Build"
# Cliquer "Add build step"
# Choisir "Execute shell"

# Script:
"""
#!/bin/bash
set -e  # Arrêter si erreur

echo "=== [RAPIDE] Démarrage du build ==="

# 1. Afficher version Python
echo "[PACKAGE] Version Python:"
python3 --version

# 2. Créer environnement virtuel
echo "[OUTIL] Création environnement virtuel..."
python3 -m venv venv

# 3. Activer l'environnement virtuel
echo "[OK] Activation venv..."
source venv/bin/activate

# 4. Mettre à jour pip
echo "[PACKAGE] Mise à jour pip..."
pip install --upgrade pip

# 5. Installer dépendances
echo "[PACKAGE] Installation dépendances..."
pip install -r requirements.txt

# 6. Afficher les packages installés
echo "[LISTE] Packages installés:"
pip list

# 7. Lancer les tests
echo "[TEST] Lancement des tests..."
pytest tests/ -v

echo "=== [OK] Build terminé avec succès ==="
"""

# Explications ligne par ligne:

# #!/bin/bash
# Indique que c'est un script bash

# set -e
# TRÈS IMPORTANT: Si une commande échoue, tout s'arrête
# Sans ça, Jenkins continuerait même en cas d'erreur

# python3 -m venv venv
# Crée un environnement virtuel nommé "venv"
# POURQUOI ? Pour isoler les dépendances
# Chaque job a ses propres packages

# source venv/bin/activate
# Active l'environnement virtuel
# Toutes les commandes suivantes utiliseront ce venv

# pip install -r requirements.txt
# Installe les packages du projet (pytest ici)

# pytest tests/ -v
# Lance TOUS les tests dans le dossier tests/
# -v : verbose (affiche détails)


# ÉTAPE 5: Sauvegarder et tester

# Cliquer "Save"

# Cliquer "Build Now"

# Cliquer sur le build #1 qui apparaît

# Cliquer "Console Output"

# Vous devriez voir:
"""
Started by user admin
Running as SYSTEM
Building in workspace /var/jenkins_home/workspace/mon-projet-test
[mon-projet-test] $ /bin/sh -xe /tmp/jenkins7890.sh
+ echo '=== [RAPIDE] Démarrage du build ==='
=== [RAPIDE] Démarrage du build ===
+ echo '[PACKAGE] Version Python:'
[PACKAGE] Version Python:
+ python3 --version
Python 3.11.5
+ echo '[OUTIL] Création environnement virtuel...'
[OUTIL] Création environnement virtuel...
+ python3 -m venv venv
+ echo '[OK] Activation venv...'
[OK] Activation venv...
+ source venv/bin/activate
+ echo '[PACKAGE] Mise à jour pip...'
[PACKAGE] Mise à jour pip...
+ pip install --upgrade pip
Requirement already satisfied: pip in ./venv/lib/python3.11/site-packages
+ echo '[PACKAGE] Installation dépendances...'
[PACKAGE] Installation dépendances...
+ pip install -r requirements.txt
Collecting pytest==7.4.0
  Downloading pytest-7.4.0-py3-none-any.whl
Installing collected packages: pytest
Successfully installed pytest-7.4.0
+ echo '[LISTE] Packages installés:'
[LISTE] Packages installés:
+ pip list
Package    Version
---------- -------
pip        23.2.1
pytest     7.4.0
+ echo '[TEST] Lancement des tests...'
[TEST] Lancement des tests...
+ pytest tests/ -v
========================= test session starts =========================
platform linux -- Python 3.11.5, pytest-7.4.0
collected 5 tests

tests/test_calculator.py::test_add PASSED                       [ 20%]
tests/test_calculator.py::test_subtract PASSED                  [ 40%]
tests/test_calculator.py::test_multiply PASSED                  [ 60%]
tests/test_calculator.py::test_divide PASSED                    [ 80%]
tests/test_calculator.py::test_divide_by_zero PASSED           [100%]

========================= 5 passed in 0.03s ==========================
+ echo '=== [OK] Build terminé avec succès ==='
=== [OK] Build terminé avec succès ===
Finished: SUCCESS
"""

# [OK] Si vous voyez "Finished: SUCCESS" -> Bravo !
# [X] Si erreur -> Lire le message d'erreur dans les logs


# === Comprendre ce qui s'est passé ===

# 1. Jenkins a cloné votre repo Git
# 2. Jenkins a créé un venv Python propre
# 3. Jenkins a installé pytest
# 4. Jenkins a lancé tous les tests
# 5. Tous les tests sont passés [OK]
# 6. Le build est marqué "SUCCESS"


# === Et si un test échoue ? ===

# Testons ! Modifier un test pour qu'il échoue:

# Éditer tests/test_calculator.py sur GitHub:
"""
def test_add():
    assert add(2, 3) == 999  # [X] Volontairement faux !
"""

# Commit et push

# Dans Jenkins, cliquer "Build Now"

# Dans les logs, vous verrez:
"""
tests/test_calculator.py::test_add FAILED                       [ 20%]

================================ FAILURES =================================
________________________________ test_add _________________________________

    def test_add():
>       assert add(2, 3) == 999
E       assert 5 == 999
E        +  where 5 = add(2, 3)

tests/test_calculator.py:8: AssertionError
===================== 1 failed, 4 passed in 0.05s =====================
Build step 'Execute shell' marked build as failure
Finished: FAILURE
"""

# Le build devient ROUGE [X]
# Jenkins vous montre EXACTEMENT où le test échoue

# C'est le RÔLE de Jenkins:
# Vous alerter IMMÉDIATEMENT quand quelque chose casse


# === Déclencher automatiquement les builds ===

# Pour l'instant, vous déclenchez manuellement avec "Build Now"
# On peut faire mieux !

# OPTION 1: À chaque push Git (Webhook)

# Dans le job Jenkins:
# Section "Build Triggers"
# [OK] Cocher "GitHub hook trigger for GITScm polling"

# Sur GitHub:
# Votre repo > Settings > Webhooks > Add webhook
# Payload URL: http://VOTRE_JENKINS:8080/github-webhook/
# Content type: application/json
# Events: Just the push event
# Save

# Maintenant, CHAQUE FOIS que vous push:
# GitHub notifie Jenkins
# Jenkins lance automatiquement un build !


# OPTION 2: Polling régulier (plus simple mais moins efficace)

# Section "Build Triggers"
# [OK] Cocher "Poll SCM"
# Schedule: H/5 * * * *

# Ceci dit à Jenkins:
# "Vérifie Git toutes les 5 minutes"
# "Si nouveau commit, lance un build"

# H/5 * * * * = Cron syntax
# H/5 : Toutes les 5 minutes (H = Hash pour répartir la charge)
# * * * * : tous les jours, toutes les heures


# OPTION 3: Build périodique (indépendant de Git)

# Section "Build Triggers"
# [OK] Cocher "Build periodically"
# Schedule: 0 2 * * *

# Ceci dit à Jenkins:
# "Lance un build tous les jours à 2h du matin"
# Utile pour:
# - Tests de régression nocturnes
# - Backups
# - Rapports quotidiens


[OK] ENVIRONNEMENTS VIRTUELS (VENV) EXPLIQUÉS

# === Pourquoi utiliser venv DANS Jenkins ? ===

# PROBLÈME: Conflits de packages

# Imaginez 2 jobs Jenkins:
# - Job A utilise Django 3.2
# - Job B utilise Django 4.0

# Si on installe GLOBALEMENT:
# pip install Django==3.2  # Pour job A
# pip install Django==4.0  # Pour job B -> ÉCRASE la version 3.2 !

# Le job A va CASSER ! [IMPACT]

# SOLUTION: Environnement virtuel

# Chaque job a son PROPRE environnement Python
# Job A -> venv avec Django 3.2
# Job B -> venv avec Django 4.0
# Pas de conflit ! [OK]


# === Comment créer un venv dans Jenkins ? ===

# Dans CHAQUE job qui utilise Python, faire:

"""
# Créer venv
python3 -m venv venv

# Activer venv
source venv/bin/activate

# Maintenant, pip installe DANS le venv
pip install -r requirements.txt

# Tous les scripts Python utiliseront ce venv
python script.py
"""


# === Où est stocké le venv ? ===

# Chemin: $WORKSPACE/venv/

# Exemple:
# /var/jenkins_home/workspace/mon-projet-test/venv/

# À l'intérieur:
"""
venv/
├── bin/          # Exécutables (python, pip, pytest...)
├── lib/          # Packages installés
└── pyvenv.cfg    # Configuration
"""


# === Le venv est-il réutilisé entre builds ? ===

# [ATTENTION] NON par défaut !

# Chaque build:
# 1. Efface le venv existant (ou le recrée)
# 2. Réinstalle TOUTES les dépendances

# C'est LENT mais PROPRE
# Garantit que chaque build part d'un état connu


# === Optimisation: Cache du venv ===

# Pour accélérer, on peut RÉUTILISER le venv:

"""
#!/bin/bash

# Vérifier si venv existe
if [ -d "venv" ]; then
    echo "[BLACK_UNIVERSAL_RECYCLING_SYMBOL] Réutilisation venv existant"
    source venv/bin/activate
    
    # Mettre à jour seulement si requirements.txt a changé
    pip install -r requirements.txt --upgrade
else
    echo "[OUTIL] Création nouveau venv"
    python3 -m venv venv
    source venv/bin/activate
    pip install -r requirements.txt
fi
"""

# Avantages:
# [OK] Beaucoup plus rapide (ne réinstalle pas tout)
# [OK] Économise bande passante

# Inconvénients:
# [ATTENTION] Possible de garder vieux packages
# [ATTENTION] Peut masquer des problèmes

# Recommandation:
# - DEV: Réutiliser le venv (rapide)
# - PROD: Recréer à chaque fois (propre)


# === Nettoyage du venv ===

# Pour forcer recréation du venv:

# Méthode 1: Dans le script
"""
#!/bin/bash

# Supprimer venv existant
rm -rf venv

# Créer nouveau venv
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
"""

# Méthode 2: Via Jenkins
# Cliquer sur le job
# "Wipe Out Workspace" dans le menu
# Efface TOUT (y compris venv)
# Prochain build repart de zéro


# === Venv avec plugin ShiningPanda ===

# Si vous avez installé le plugin ShiningPanda:

# Dans la configuration du job:
# Section "Build Environment"
# [OK] Cocher "Virtualenv Builder"

# Configuraiton:
# - Python version: System-CPython-3.11
# - Name: venv
# - Nature: Shell
# - Command:
"""
pip install -r requirements.txt
pytest tests/
"""

# ShiningPanda:
# [OK] Crée automatiquement le venv
# [OK] L'active automatiquement
# [OK] Le nettoie après le build

# Plus simple mais moins flexible


# === Plusieurs versions de Python ===

# Parfois, vous devez tester sur PLUSIEURS versions Python:
# - Python 3.9
# - Python 3.10
# - Python 3.11

# Solution: Matrice de jobs

# Script de test multi-versions:
"""
#!/bin/bash

# Liste des versions à tester
PYTHON_VERSIONS="python3.9 python3.10 python3.11"

for PYTHON in $PYTHON_VERSIONS; do
    echo "=== Test avec $PYTHON ==="
    
    # Créer venv avec cette version
    $PYTHON -m venv venv-$PYTHON
    source venv-$PYTHON/bin/activate
    
    # Installer et tester
    pip install -r requirements.txt
    pytest tests/
    
    # Désactiver venv
    deactivate
    
    echo "[OK] $PYTHON OK"
    echo ""
done
"""

# Ou utiliser un Pipeline avec matrice (voir section Pipelines)


[OK] TESTS PYTHON DANS JENKINS (DÉTAILLÉ)

# === Introduction aux tests ===

# Les TESTS = code qui vérifie que VOTRE code marche

# Exemple:
# Vous avez une fonction add(a, b)
# Un test vérifie: add(2, 3) == 5

# POURQUOI tester ?
# - Détecter les bugs AVANT la production
# - Avoir confiance pour changer le code
# - Documentation vivante (les tests montrent comment utiliser le code)


# === Framework de test: pytest ===

# pytest = outil le plus populaire pour tester en Python

# Installation:
pip install pytest

# Créer un test:
#