CI/CD pour les projets Rust : GitHub Actions — Partie 2 : Tests et déploiement

Dans la première partie, nous avons configuré un pipeline de construction de base pour un projet Rust. Maintenant, en approfondissant la programmation en Rust, nous allons examiner les tests automatisés, le linting et le déploiement. C'est une étape obligatoire de l'apprentissage de Rust pour les débutants qui souhaitent écrire du code professionnel. Aujourd'hui, vous apprendrez à rendre votre CI/CD vraiment utile.

1. Exécution des tests et vérification de la couverture

Tout projet Rust sérieux nécessite une exécution automatique des tests. Dans GitHub Actions, cela se fait avec la commande cargo test. Cependant, pour en tirer le meilleur parti, ajoutez la vérification de la couverture de code avec tarpaulin.

Configuration de l'environnement de test

Ajoutez une étape à votre fichier de workflow (.github/workflows/ci.yml) :

name: CI for Rust

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      - name: Run tests
        run: cargo test --verbose
      - name: Generate coverage
        run: |
          cargo install cargo-tarpaulin
          cargo tarpaulin --out Xml
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

Ce code montre à quel point il est facile d'intégrer Rust avec des services externes. cargo tarpaulin créera un rapport qui pourra être téléchargé vers Codecov ou Coveralls. Pour les débutants en Rust, il est important de comprendre : les tests sont votre première ligne de défense.

2. Linting et formatage

Un code de qualité n'est pas seulement un code fonctionnel, mais aussi un code lisible. En Rust, il existe deux outils puissants : clippy (linter) et rustfmt(formateur). Incluez-les dans le pipeline.

Ajout de Clippy et Rustfmt

Ajoutez un nouveau job ou étendez celui existant :

  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          components: clippy, rustfmt
      - name: Check formatting
        run: cargo fmt -- --check
      - name: Run Clippy
        run: cargo clippy -- -D warnings

Le flag -D warnings transforme les avertissements en erreurs. C'est strict mais efficace pour l'apprentissage : vous découvrirez immédiatement les problèmes potentiels. Rappelez-vous qu'en programmation Rust, la rigueur est un avantage.

3. Déploiement automatique sur GitHub Pages

Lorsque les tests et le linting ont réussi, vous pouvez publier automatiquement la documentation. Rust génère la documentation via cargo doc. Le déploiement sur GitHub Pages est un excellent moyen de présenter les résultats.

Workflow pour le déploiement

Créez un fichier séparé .github/workflows/deploy.yml :

name: Deploy Documentation

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
      - name: Build documentation
        run: cargo doc --no-deps --document-private-items
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./target/doc

Ce pipeline se déclenche uniquement lors des pushs sur la branche main. Il génère la documentation et la publie. Pour les débutants en Rust, c'est un excellent moyen de montrer vos projets au monde.

4. Optimisation du temps de construction : mise en cache

La construction de projets Rust peut prendre du temps. GitHub Action