Aller au contenu principal

TP5 — Pull Requests & Workflows d'équipe

Travaux Pratiques 60 min Module 04

Objectifs​

À la fin de ce TP, vous aurez pratiqué :

  • Créer des Pull Requests bien documentées
  • Effectuer une revue de code avec des commentaires constructifs
  • Adresser les retours de revue
  • Utiliser les suggestions de code GitHub
  • Fusionner une PR avec la bonne stratégie
  • Appliquer GitHub Flow sur un projet réel

Mise en place​

# Utiliser le dépôt créé lors du TP4 ou créer un nouveau
gh repo create git-tp5-pr-workflow \
  --public \
  --description "TP5 - Pull Requests et Workflows" \
  --clone
cd git-tp5-pr-workflow

Créez la structure initiale :

mkdir src tests

Créez src/calculatrice.py :

class Calculatrice:
    """Une calculatrice simple."""
    
    def additionner(self, a, b):
        return a + b
    
    def soustraire(self, a, b):
        return a - b
    
    def multiplier(self, a, b):
        return a * b
    
    def diviser(self, a, b):
        if b == 0:
            raise ValueError("Division par zéro impossible")
        return a / b

Créez README.md :

# Calculatrice

Une calculatrice Python simple avec tests unitaires.

## Installation
```bash
pip install pytest

Tests​

pytest tests/

```bash
git add .
git commit -m "feat: projet calculatrice initial"
git push -u origin main

Partie 1 : Créer une PR bien documentée​

# Créer une branche de fonctionnalité
git switch -c feature/operateurs-avances

Ajoutez à src/calculatrice.py :

    def puissance(self, base, exposant):
        """Calculer base élevé à la puissance exposant."""
        return base ** exposant
    
    def racine_carree(self, nombre):
        """Calculer la racine carrée."""
        if nombre < 0:
            raise ValueError("Impossible de calculer la racine carrée d'un nombre négatif")
        return nombre ** 0.5
    
    def modulo(self, a, b):
        """Calculer le reste de la division."""
        if b == 0:
            raise ValueError("Modulo par zéro impossible")
        return a % b

Créez tests/test_calculatrice.py :

import pytest
from src.calculatrice import Calculatrice

@pytest.fixture
def calc():
    return Calculatrice()

def test_puissance(calc):
    assert calc.puissance(2, 10) == 1024
    assert calc.puissance(3, 0) == 1

def test_racine_carree(calc):
    assert calc.racine_carree(9) == 3.0
    assert calc.racine_carree(0) == 0.0

def test_racine_carree_negatif(calc):
    with pytest.raises(ValueError):
        calc.racine_carree(-1)

def test_modulo(calc):
    assert calc.modulo(10, 3) == 1
    assert calc.modulo(10, 2) == 0
git add .
git commit -m "feat(calc): ajouter puissance, racine carrée et modulo avec tests"
git push -u origin feature/operateurs-avances

# Créer une PR bien documentée
gh pr create \
  --title "feat(calc): opérateurs mathématiques avancés" \
  --base main \
  --body "## Description

Ajoute 3 nouveaux opérateurs mathématiques à la calculatrice :
- **Puissance** : \`base ** exposant\`
- **Racine carrée** : avec validation pour les négatifs
- **Modulo** : reste de la division entière

## Tests
15 nouveaux tests unitaires ajoutés, couvrant :
- Cas nominaux
- Cas limites (0, 1)
- Cas d'erreur (valeurs invalides)

## Comment tester
\`\`\`bash
pytest tests/test_calculatrice.py -v
\`\`\`

Closes #1"

Partie 2 : Effectuer une revue de code​

# Voir la PR créée
gh pr list
gh pr view 1

# Checkout de la PR pour tester localement
gh pr checkout 1

# Tester le code
python -m pytest tests/ -v

# Revenir sur main
git switch main

Sur l'interface GitHub, effectuez une revue en ajoutant ces types de commentaires :

  1. Commentaire positif sur une ligne de code : "Bonne gestion de l'erreur pour la racine carrée négative !"
  2. Suggestion d'amélioration : Proposer d'utiliser math.sqrt() au lieu de ** 0.5
  3. Question : "Devrions-nous retourner un complexe pour les racines carrées négatives ?"
# Approuver la PR
gh pr review 1 --approve --body "Bon travail ! Code propre et bien testé."

Partie 3 : Adresser les retours​

git switch feature/operateurs-avances

# Adresser les suggestions de la revue

Mettez à jour src/calculatrice.py pour utiliser le module math :

import math

    def racine_carree(self, nombre):
        """Calculer la racine carrée."""
        if nombre < 0:
            raise ValueError("Impossible de calculer la racine carrée d'un nombre négatif")
        return math.sqrt(nombre)
git add src/calculatrice.py
git commit -m "refactor(calc): utiliser math.sqrt() selon les retours de revue"
git push

# Répondre à la revue
gh pr comment 1 --body "J'ai mis à jour pour utiliser math.sqrt() comme suggéré. Merci pour la revue !"

Partie 4 : Fusionner la PR​

# Vérifier que tout est prêt
gh pr view 1

# Fusionner avec squash (historique propre)
gh pr merge 1 --squash --delete-branch \
  --subject "feat(calc): ajouter opérateurs mathématiques avancés"

# Mettre à jour la branche locale main
git switch main
git pull

# Voir l'historique propre
git log --oneline

Partie 5 : Simuler GitHub Flow complet​

Répétez le cycle pour une deuxième fonctionnalité :

# Branche 2 : Historique des calculs
git switch -c feature/historique

# Ajouter à src/calculatrice.py :
    def __init__(self):
        self.historique = []
    
    def _enregistrer(self, operation, resultat):
        """Enregistrer une opération dans l'historique."""
        self.historique.append({"operation": operation, "resultat": resultat})
    
    def obtenir_historique(self):
        """Obtenir tout l'historique des calculs."""
        return self.historique.copy()
    
    def effacer_historique(self):
        """Effacer l'historique des calculs."""
        self.historique = []
git add .
git commit -m "feat(calc): ajouter le système d'historique des calculs"
git push -u origin feature/historique

gh pr create \
  --title "feat(calc): historique des calculs" \
  --base main \
  --body "Ajoute un système de suivi de l'historique des calculs."

# Auto-approuver (dans un vrai projet, quelqu'un d'autre approuverait)
gh pr review 2 --approve

gh pr merge 2 --squash --delete-branch
git switch main && git pull

Checklist de validation​

  • 2 Pull Requests créées avec des descriptions complètes
  • Des commentaires de revue ajoutés (au moins 2 types différents)
  • Les retours de revue adressés avec un nouveau commit
  • Les 2 PRs fusionnées avec squash
  • git log --oneline montre 2 commits propres avec les fonctionnalités

Résumé​

Dans ce TP vous avez pratiqué :

  • La création de PRs bien documentées
  • La revue de code professionnelle
  • L'adressage des retours de revue
  • La fusion avec différentes stratégies
  • GitHub Flow de bout en bout

Vous êtes prêt pour le Module 05 — Git Avancé !