Automatisation des Tests et CI avec Symfony et GitHub Actions

13 avril 2024

9 min de lecture

1. Introduction à l'automatisation des tests 2. Préparation des tests avec Symfony 3. Automatisation des tests avec GitHub Actions 4. Gestion des erreurs et débogage 5. Déploiement continu avec GitHub Actions 6. Cas d'usage: Intégration de Symfony et GitHub Actions 7. Vue d'ensemble du processus d'automatisation 8. Perspectives d'évolution

1. Introduction à l'automatisation des tests

L'automatisation des tests est une pratique cruciale dans le développement d'applications modernes, surtout dans un environnement agile et Lean. Elle permet une validation rapide et fiable de la qualité du code.

1.1 Pourquoi automatiser les tests ?

Autrefois, les tests étaient principalement effectués manuellement par des humains. Si cette pratique a fait ses preuves, elle présente cependant des limites notamment en matière de rapidité et de fiabilité. Avec l'automatisation, vous pouvez:

Réduire les erreurs. Les humains peuvent oublier ou négliger certains scénarios de test, ce qui n'est pas le cas des machines.
Réduire les coûts. Les tests manuels demandent beaucoup de temps et de ressources. Avec l'automatisation, vous pouvez effectuer des tests 24/7 sans coût supplémentaire.
Augmenter la vitesse de déploiement. Plus vous pouvez tester rapidement, plus vous pouvez déployer rapidement.

1.2 Les avantages de l'automatisation des tests

Au-delà de la réduction des coûts et des erreurs, l'automatisation des tests apporte de nombreux avantages :

Couverture de test étendue. Avec l'automatisation, vous pouvez tester chaque fonctionnalité en profondeur et de manière exhaustive.
Rapidité de feedback. Les tests automatisés fournissent rapidement des informations sur la qualité du code. Ainsi, vous pouvez corriger rapidement les erreurs.

1.3 Les différentes approches de l'automatisation des tests

Il existe plusieurs méthodes pour automatiser les tests de votre application. La première étape consiste à utiliser un framework de test. En PHP, PHPUnit est un choix populaire qui offre des fonctionnalités complètes pour tous vos besoins de test.

Ensuite, vous pouvez intégrer l'exécution de vos tests dans un processus d'intégration continue (CI). Des plateformes comme GitHub Actions ou Jenkins permettent d'effectuer automatiquement votre suite de tests à chaque changement de code.

Finalement, l'automatisation des tests peut inclure des tests plus avancés comme les tests de performance, les tests de bout-en-bout ou même l'automatisation du déploiement.

2. Préparation des tests avec Symfony

2.1 Configuration de l'environnement de test avec Symfony

Pour instaurer un système de test fiable et automatisé, le choix de l'environnement est crucial. Symfony fournit un environnement dédié pour l’exécution des tests, séparé de l’environnement de développement. Il faut tout d'abord installer les dépendances nécessaires au système de test Symfony avec le gestionnaire de dépendances Composer. Voici la commande pour cela :

1composer require --dev symfony/phpunit-bridge

Ensuite, il faut modifier le fichier .env.test pour configurer les paramètres spécifiques à l'environnement de test. Typiquement, nous voulons utiliser une base de données de test distincte pour éviter de mélanger les données réelles avec les données de test.

2.2 Création de tests unitaires et fonctionnels

Dans Symfony, la création de tests est facilitée grâce à l'utilisation de classes et de méthodes prédéfinies. Vous pouvez créer des tests unitaires, qui se concentrent sur une petite partie du code, généralement une fonction ou une méthode, ainsi que des tests fonctionnels, qui testent le comportement de l'application dans son ensemble.

Pour créer un test unitaire, vous pouvez utiliser la commande suivante :

1php bin/console make:test Unit\MyClassTest

Cette commande va générer une classe de test dans le répertoire tests/Unit/. Vous pouvez ensuite ajouter des méthodes pour tester les différentes fonctionnalités de votre classe.

Pour les tests fonctionnels, vous pouvez utiliser la commande make:functional-test :

1php bin/console make:functional-test HomeControllerTest

2.3 Validation des tests avec PHPUnit

Symfony utilise PHPUnit pour l'exécution des tests. Pour lancer vos tests, utilisez la commande suivante :

1./bin/phpunit

Cette commande exécutera tous vos tests et affichera un rapport détaillé avec le nombre de tests passés, échoués et les erreurs éventuelles. Il est essentiel de toujours vérifier les rapports et de corriger les erreurs avant de passer à la prochaine étape de votre processus de développement.

Important : Assurez-vous de bien comprendre le fonctionnement des tests PHPUnit et de savoir comment analyser les résultats des tests. C'est une compétence clé pour l'automatisation des tests et l'intégration continue.

Vous trouverez plus d'informations sur la création de tests avec Symfony dans la documentation officielle de Symfony.

3. Automatisation des tests avec GitHub Actions

3.1 Configuration de GitHub Actions

GitHub Actions est une fonctionnalité de GitHub qui vous permet d'automatiser des tâches logicielles workflow. Pour commencer à l'utiliser, vous aurez besoin d'un fichier de configuration dans votre dépôt. Ce fichier peut se trouver dans un repértoire .github/workflows dans la racine du projet. Par exemple, vous pouvez créer un fichier ci.yml et y déclarer vos tâches.

Remarque : Les fichiers de configuration de GitHub Actions sont écrits en YAML, un format de données adapté pour la structuration des tâches.

Voici un exemple de configuration de base de votre fichier ci.yml:

1name: CI
2on: push
3jobs:
4  build:
5    runs-on: ubuntu-latest
6    steps: 
7    - name: Check out code
8      uses: actions/checkout@v2

Dans cet exemple, le flux de travail est déclenché à chaque fois que du code est poussé sur le dépôt. Ensuite, le code du dépôt est extrait et prêt à être utilisé pour d'autres tâches.

3.2 Création d'un workflow de test

La prochaine étape consiste à configurer une tâche pour exécuter les tests. Pour cela, vous pouvez ajouter une nouvelle étape à votre fichier ci.yml. Puisque nous utilisons Symfony et que PHPUnit est souvent utilisé pour les tests, vous pouvez l'installer et exécuter les tests.

1#...
2steps:
3- name: Check out code
4  uses: actions/checkout@v2
5- name: Install dependencies
6  run: composer install
7- name: Run tests
8  run: ./vendor/bin/phpunit

L'installation des dépendances se fait grâce à Composer, le gestionnaire de dépendances de PHP. Ensuite, les tests sont exécutés avec PHPUnit.

3.3 Exécution des tests sur GitHub Actions

Il ne vous reste plus qu'à pousser votre code sur GitHub. Vos tests seront exécutés automatiquement comme déclaré dans votre flux de travail. Si vos tests passent, une coche verte apparaît pour le commit dans GitHub. En revanche, si vos tests échouent, une croix rouge apparaît.

Note : Si vous avez activé les notifications, vous pouvez également recevoir par email les informations concernant l'échec des tests.

Pour consulter les détails des tests, vous pouvez cliquer sur le lien Details qui vous redirigera vers la page de votre flux de travail dans GitHub Actions. Vous pourrez ainsi consulter les journaux d'exécution et déboguer si nécessaire.

A savoir GitHub Actions est gratuit pour les projets open source, bien qu'il existe des limites pour les utilisateurs gratuits et payants en fonction du nombre d'exécutions et des minutes utilisées.

4. Gestion des erreurs et débogage

4.1 Comprendre les erreurs de test

L'automatisation des tests ne garantit pas l'absence d'erreurs, il est donc crucial de comprendre comment identifier et résoudre les erreurs qui peuvent survenir. Les erreurs courantes peuvent inclure des tests échoués, des temps d'exécution longs, et des dépendances manquantes.

Note: Lorsqu'une erreur survient lors d'un test, le rapporteur d'erreur PHPUnit affichera généralement un message d'erreur détaillé.

4.2 Techniques de débogage dans Symfony

Symfony offre plusieurs méthodes de débogage. Voici quelques-uns des plus efficaces :

Dumper de variable: Le composant VarDumper permet de déposer facilement une variable avec la méthode dump().

1dump($variable);

Barre de débogage: Symfony fournit une barre de débogage pratique en bas de la page, qui affiche une grande quantité d'informations utiles.
Profiler: Un outil puissant fournissant des informations détaillées sur chaque demande faite à votre application.

1use Symfony\Component\HttpFoundation\Response;
2use Symfony\Component\VarDumper\Cloner\VarCloner;
3use Symfony\Component\VarDumper\Dumper\CliDumper;
4use Symfony\Component\VarDumper\Dumper\HtmlDumper;
5
6$dumper = 'cli' === PHP_SAPI ? new CliDumper : new HtmlDumper;
7$cloner = new VarCloner;
8
9foreach ($data as $i => $row) {
10    $dumper->dump($cloner->cloneVar($row));
11}
12return new Response('<html></html>');

4.3 Utilisation des outils de débogage de GitHub Actions

GitHub Actions fournit une fonction d'enregistrement qui peut être utilisée pour déboguer les actions. En ajoutant steps.debug.outputs.runner.toJson(), vous pouvez afficher les détails complets de l'étape.

Important: Pour activer le mode de débogage pour un workflow, définissez ACTIONS_STEP_DEBUG dans les secrets de dépôt pour true.

1jobs:
2Build:
3    runs-on: ubuntu-latest
4    steps:
5    - name: Display the runner context
6      env:
7        ACTIONS_STEP_DEBUG: ${{ secrets.ACTIONS_STEP_DEBUG }}

GitHub fournit également des actions de débogage que vous pouvez utiliser pour obtenir des informations plus détaillées sur votre workflow.

5. Déploiement continu avec GitHub Actions

5.1 Création d'un workflow de déploiement

Après avoir eu recours aux GitHub Actions pour effectuer nos tests, il est temps d'automatiser le déploiement, pour créer un système d'intégration continue. Le fichier .github/workflows/deploy.yml doit être créé en précisant la branche à déployer. Voici un exemple de configuration pour un déploiement sur une branche nommée "production" :

1name: deploy
2
3on:
4  push:
5    branches:
6      - production

Votre workflow doit ensuite spécifier les étapes de déploiement. Typiquement, ces étapes incluent la mise en place de l'environnement, l'installation des dépendances, le build de l'application et enfin, le déploiement lui-même. Voici un exemple concret avec une application Symfony déployée sur un serveur distant via SSH :

1jobs:
2  deploy:
3    runs-on: ubuntu-latest
4
5    steps:
6      - name: Checkout code
7        uses: actions/checkout@v2
8
9      - name: Setup PHP
10        uses: shivammathur/setup-php@v2
11        with:
12          php-version: '7.4'
13
14      - name: Install Dependencies
15        run: composer install
16
17      - name: Build
18        run: php bin/console cache:clear
19
20      - name: Deploy to server
21        uses: appleboy/ssh-action@master
22        with:
23          host: ${{ secrets.SERVER_HOST }}
24          username: ${{ secrets.SERVER_USER }}
25          key: ${{ secrets.SERVER_KEY }}
26          script: 'cd /var/www/myapp && git pull origin production && composer install --no-dev && php bin/console cache:clear --env=prod'

5.2 Configuration du déploiement continu

La définition des "secrets" est une étape cruciale pour ne pas exposer les informations sensibles (Attention, il ne faut jamais versionner des informations sensibles comme des clés SSH ou des tokens API). Les secrets sont définis au niveau du repository dans l'onglet "Settings". Les secrets peuvent ensuite être référencés dans nos workflows GitHub Actions grâce à la notation secrets.{nom_du_secret}.

La stratégie de déploiement va dépendre de votre infrastructure et de vos besoins. Vous pouvez par exemple déclencher le déploiement uniquement sur la branche "production", ou bien déployer différentes versions de votre application pour chaque branche.

5.3 Gestion des erreurs de déploiement

Il est également important de pouvoir gérer les erreurs de déploiement et d'être averti en cas de problème. GitHub Actions offre plusieurs options de notification. Vous pouvez par exemple configurer une notification par e-mail en cas d'échec du déploiement.

Enfin, n'hésitez pas à profiter du système de logging intégré à GitHub Actions pour déboguer les erreurs de déploiement. Chaque run de workflow est accompagné d'un journal détaillé visible depuis l'interface GitHub.

Pour aller plus loin, vous pouvez consulter la documentation officielle de GitHub Actions autour du déploiement continu.

6. Cas d'usage: Intégration de Symfony et GitHub Actions

Dans cette section, nous allons examiner un cas d'utilisation concret de l'intégration de Symfony et GitHub Actions.

6.1 Présentation du cas d'usage

Considérons un projet Symfony où nous souhaitons automatiser les tests et le déploiement. Notre but est de garantir la qualité du code et de faciliter le processus de déploiement. À chaque fois que nous effectuons un push ou une merge request vers la branche principale, nous voulons que GitHub Actions lance automatiquement une suite de tests et déploie l'application si tous les tests passent.

6.2 Mise en œuvre de l'intégration

Pour mettre en œuvre cette intégration, nous devons configurer un workflow dans GitHub Actions. Voici un exemple de fichier de workflow main.yml:

1name: Symfony CI
2
3on:
4  push:
5    branches:
6      - main
7
8jobs:
9  build:
10    runs-on: ubuntu-latest
11
12    steps:
13    - uses: actions/checkout@v2
14
15    - name: Cache Composer packages
16      uses: actions/cache@v2
17      with:
18        path: vendor
19        key: ${{ runner.OS }}-composer-${{ hashFiles('**/composer.lock') }}
20        restore-keys: ${{ runner.OS }}-composer-
21
22    - name: Install dependencies
23      run: composer install
24
25    - name: PHPUnit Tests
26      run: ./vendor/bin/phpunit
27
28    - name: Deploy to Production
29      if: github.ref == 'refs/heads/main'
30      run: echo "Deploying to production"

Ce workflow commence par vérifier notre repo et mettre en cache les paquets Composer. Il installe ensuite les dépendances, exécute PHPUnit pour lancer notre suite de tests, et enfin, si tous les tests passent et que nous sommes sur la branche main, le déploiement est lancé.

6.3 Résultats et observations

Remarque : Amazon Web Services (AWS) est un excellent choix pour le déploiement de nos applications Symfony.

Après avoir configuré notre workflow, chaque push ou merge request va maintenant déclencher automatiquement notre suite de tests ainsi que le déploiement si les tests passent.

Notre approche garantit que le code de la branche principale est toujours stable et prêt à être déployé, facilitant ainsi le processus de déploiement.

En résumé, l'intégration de Symfony et GitHub actions offre à notre équipe un environnement de développement conçu pour assurer une qualité de code optimale tout en simplifiant le processus de déploiement.

7. Vue d'ensemble du processus d'automatisation

7.1 L'importance de l'intégration continue

L'intégration continue (CI) est un processus de développement logiciel qui implique l'intégration fréquente du travail des développeurs dans un dépôt central. Les changements sont vérifiés par des builds automatisés (y compris les tests) pour détecter les erreurs de manière précoce.

1# Example de script CI
2name: CI
3  
4on:
5  push:
6    branches: [ master ]
7  pull_request:
8    branches: [ master ]
9
10jobs:
11  build:
12
13    runs-on: ubuntu-latest
14
15    steps:
16    - uses: actions/checkout@v2
17    - name: Run tests
18      run: make test

7.2 Bilan de l'automatisation des tests et du déploiement

L'automatisation des tests et du déploiement avec Symfony et GitHub Actions offre de nombreux avantages.

Accélération des tests: Grâce à l'automatisation, les tests peuvent être exécutés en parallèle, réduisant ainsi le temps d'exécution global.
Répétabilité: Les tests automatisés peuvent être répétés à l'envi, garantissant ainsi la stabilité du projet.
Fiabilité: Les tests automatisés réduisent le risque d'erreur humaine, fournissant ainsi des résultats plus fiables.
Application des meilleures pratiques: L'utilisation de GitHub Actions permet d'adopter les meilleures pratiques en matière de CI/CD.

Un outil comme SonarQube peut être utilisé pour analyser la qualité du code et détecter les bugs et les vulnérabilités.

7.3 Conseils pour optimiser le processus d'automatisation

Pour améliorer encore le processus d'automatisation, voici quelques conseils:

Pensez à automatiser dès le départ. Il est plus facile d'automatiser les tests dès le début du projet plutôt que de le faire plus tard.
Restez à jour. Il est important de toujours utiliser les dernières versions de Symfony et de GitHub Actions.
Documentez. Assurez-vous que le processus d'automatisation est bien documenté afin que d'autres développeurs puissent facilement comprendre et maintenir le code.
Planifiez et surveillez. Il est crucial de surveiller les résultats des tests et de planifier en conséquence.

8. Perspectives d'évolution

8.1 Automatisation avancée avec Symfony

Symfony vous offre une grande variété d'outils pour pousser l'automatisation à un niveau supérieur. Par exemple, vous pourriez envisager l'implémentation de Behat pour une approche de développement piloté par le comportement (BDD). Voici un exemple de l'utilisation de Behat avec Symfony :

1default:
2    extensions:
3        Behat\Symfony2Extension: ~
4        Behat\MinkExtension:
5            sessions:
6                default:
7                    symfony2: ~

De plus, vous pouvez envisager l'utilisation de l'extension PHPUnit Bridge qui fournit des outils pour faciliter les tests de l'application dans différents environnements.

8.2 Intégrer d'autres outils avec GitHub Actions

GitHub Actions est suffisamment flexible pour vous permettre d'intégrer des outils externes à votre processus CI/CD. Vous pouvez, par exemple, intégrer des outils d'analyse de code comme SonarCloud pour améliorer davantage la qualité de votre code. Voici comment vous pouvez ajouter SonarCloud à votre workflow GitHub Actions :

1name: SonarCloud scan
2on:
3  push:
4    branches:
5      - master
6  pull_request:
7    types: [opened, synchronize, reopened]
8jobs:
9  SonarCloud:
10    runs-on: ubuntu-latest
11    steps:
12    - uses: actions/checkout@v2
13      with:
14        fetch-depth: 0
15    - name: SonarCloud
16      uses: SonarSource/sonarcloud-github-action@master

8.3 Tenir compte des tendances et des évolutions technologiques

Le monde de l'automatisation de tests et du CI/CD évolue rapidement. Pour rester à la pointe, vous devrez vous tenir informé des dernières tendances et évolutions technologiques. Attention, ne vous précipitez pas pour adopter une nouvelle technologie simplement parce qu'elle est à la mode. Chaque outil a ses propres avantages et inconvénients et son utilisation doit être soigneusement considérée en fonction des besoins de votre projet. Un avantage notable est l'incorporation de l'IA dans le processus de test comme le propose STAF ou Testim.io, ce qui peut accroître l'efficacité des tests. Toutefois, l'adoption de ces nouvelles technologies doit être soigneusement réfléchie car elle peut introduire de nouveaux challenges et exigences. Il est donc recommandé de faire des recherches approfondies et des essais avant de décider de leur adoption.