Implémentation de CI/CD pour ReadmeGenie

Pourquoi CI/CD ?

Avant de plonger dans la configuration, expliquons brièvement pourquoi CI/CD est si critique :

1. Tests automatisés : l'exécution de tests garantit automatiquement la stabilité du code à chaque modification.
2. Cohérence : CI/CD applique les normes (peluchage, formatage) dans toute la base de code.
3. Fiabilité : les contrôles et tests automatisés minimisent les erreurs humaines et améliorent la fiabilité du code.
4. Commentaires rapides : les développeurs reçoivent un retour immédiat sur la qualité du code, ce qui permet de détecter rapidement les problèmes.

Dans ReadmeGenie, nous avons utilisé GitHub Actions comme outil CI/CD. Il s'intègre parfaitement aux référentiels GitHub et offre flexibilité et automatisation grâce aux fichiers de configuration YAML.

Le pipeline CI/CD pour ReadmeGenie

Notre pipeline CI/CD comprend les étapes automatisées suivantes :

1. Vérifications du peluchage et du formatage : nous exécutons Ruff et Black pour garantir le style et la cohérence du code.
2. Tests unitaires : nous utilisons le test unitaire pour vérifier que les modifications de code n'interrompent pas les fonctionnalités existantes.
3. Analyse de couverture : nous utilisons Coverage.py pour nous assurer que le code atteint notre seuil de couverture avant qu'une validation ne soit autorisée.
4. Pre-Commit Hooks : nous avons ajouté des hooks pour appliquer des contrôles de qualité locaux avant de pousser les modifications.

Présentation du flux de travail des actions GitHub

Le workflow CI est défini dans .github/workflows/python-app.yml. Voici un aperçu de ce que fait chaque partie du flux de travail :

1. Déclencher le flux de travail

Le workflow s'exécute à chaque demande push et pull vers la branche principale. Cela garantit que toutes les modifications de code sont validées avant d'être fusionnées en production.

name: Python application

on:
  push:
    branches: ["main"]
  pull_request:
    branches: ["main"]

2. Configuration de l'environnement Python

Nous configurons GitHub Actions pour utiliser Python 3.12.x, garantissant ainsi la cohérence avec notre environnement de développement local. Cette étape installe la version spécifique de Python et prépare l'environnement pour l'installation des dépendances.

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Set up Python 3.12.x
        uses: actions/setup-python@v3
        with:
          python-version: "3.12.x"

3. Installation des dépendances

L'étape suivante consiste à installer les dépendances du projet. Ici, nous mettons à niveau pip et installons le fichier exigences.txt, il installera les dépendances supplémentaires qui y sont spécifiées.

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install flake8 pytest
          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi

4. Exécution de contrôles de peluchage et de qualité du code

Le peluchage est une partie cruciale de notre flux de travail, garantissant que le code respecte les normes de qualité spécifiées. Nous exécutons flake8 avec des options pour signaler les erreurs de syntaxe, les noms non définis et les problèmes de complexité.

name: Python application

on:
  push:
    branches: ["main"]
  pull_request:
    branches: ["main"]

5. Exécution de tests avec analyse de couverture

Pour les tests unitaires, nous utilisons pytest pour exécuter tous les cas de test. De plus, nous utilisons la couverture pour suivre quelles lignes de code sont testées, garantissant ainsi que notre suite de tests respecte le seuil de couverture défini de 75 %.

Les commandes suivantes exécutent les tests et génèrent un rapport de couverture, mettant en évidence les éventuelles lacunes dans la couverture des tests. Ceci est essentiel pour l’assurance qualité, car le code non testé est une source potentielle de futurs bugs.

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
      - name: Set up Python 3.12.x
        uses: actions/setup-python@v3
        with:
          python-version: "3.12.x"

Cette vérification de couverture garantit un niveau élevé de qualité du code en garantissant qu'au moins 75 % de la base de code est couverte par des tests. Si la couverture tombe en dessous de ce seuil, le commit ne sera pas autorisé.

Intégration des hooks de pré-validation

En plus de CI/CD, nous avons mis en place des hooks de pré-commit pour appliquer la qualité du code localement avant que toute modification ne soit transmise au référentiel. Ces crochets :

• Exécutez Ruff pour le peluchage et Black pour le formatage.
• Appliquez un seuil de couverture minimum en exécutant les tests avec couverture localement.

Voici comment nous avons ajouté la vérification de couverture en tant que hook de pré-commit dans .pre-commit-config.yaml :

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install flake8 pytest
          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi

Défis et leçons apprises

La configuration de CI/CD nécessitait une compréhension approfondie de la façon dont les différents outils (flake8, pytest, couverture) interagissent au sein de GitHub Actions. Voici quelques défis auxquels nous avons été confrontés et les solutions que nous avons mises en œuvre :

Gestion des configurations locales et distantes divergentes

Nous avons rencontré des problèmes avec des conflits de variables d'environnement, en particulier lors des tests d'intégration d'API et de gestion de la configuration. L'utilisation de @patch.dict et d'autres techniques de moquerie dans unittest nous a permis de simuler efficacement l'environnement.

Couverture des tests et seuils

Le plus grand défi était d'assurer une couverture adéquate des tests. L'utilisation de cover.py avec --fail-under=75 dans les actions GitHub et les hooks de pré-validation a contribué à appliquer cette norme.

Améliorations futures

Pour rendre le pipeline CI/CD plus robuste, nous prévoyons de :

1. Ajouter des étapes de déploiement : automatisez le déploiement dans un environnement de test ou de production une fois les tests réussis.
2. Automatisez les badges de qualité du code : ajoutez des badges dynamiques pour afficher la couverture, l'état de peluchage et les résultats des tests dans le fichier README.
3. Étendez les exigences de couverture : augmentez le seuil de couverture à mesure que nous améliorons les tests et couvrons davantage de cas extrêmes.

Emporter

Grâce à ce projet, j'ai réalisé l'importance d'établir dès le début des tests robustes et des pratiques CI/CD. Si je devais recommencer, je me concentrerais sur la rédaction de tests complets dès le début et sur leur extension et leur amélioration progressives à mesure que le projet progresse. Cette approche éviterait les branches manquantes ou les zones non testées et garantirait que tout nouveau code s'intègre en douceur dans une base de code bien couverte.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!