Test unitaire

Le test unitaire

Le test unitaire est une technique de test software permettant de vérifier la fonctionnalité de chacun des composants (ou unités) d'un programme, indépendamment du reste de l'application.

Une « unité » désigne généralement la plus petite partie testable d'un programme, telle qu'une fonction, une méthode, une classe ou un script. En décomposant des scripts ou des algorithmes complexes en unités plus petites, des tests précis et ciblés peuvent être développés pour valider la fonctionnalité de chaque composant.

Pourquoi le test unitaire est-il important ?

En effectuant des tests unitaires sur les différentes unités dès le début, vous pouvez détecter et corriger les erreurs, ce qui permet d'obtenir un code plus fiable et des projets de débuggage moins complexes et moins longs. Cette pratique contribue également au développement d'un software modulaire et simple à maintenir, ce qui en retour améliore la qualité du code.

Avantages et défis du test unitaire

Le test unitaire présente plusieurs avantages :

• Les tests unitaires sont souvent plus faciles à écrire et plus rapides à exécuter que les tests de l'ensemble du système ou les tests plus exhaustifs.
• Il est souvent plus facile d'identifier et d'isoler les bugs lors des premières étapes.
• Ces tests peuvent vous aider à identifier des problèmes avec d'autres parties du software, en réduisant au minimum le nombre d'interactions entre les sous-systèmes.
• Vous pouvez commencer le test unitaire dès les premières étapes du développement, sans attendre que l'application soit entièrement terminée. 

Toutefois, certains problèmes ne peuvent pas être détectés en testant individuellement chaque unité.

Quand effectuer le test unitaire ?

Pour garantir la qualité du code et mesurer les effets des modifications apportées au code, le test unitaire doit être effectué tout au long du processus de développement :

• Pendant le développement : écrivez les tests unitaires à mesure du développement des nouvelles fonctionnalités. Cette approche permet de s'assurer que chaque composant fonctionne comme prévu dès le départ.
• Lors de la refactorisation : utilisez des tests unitaires pour vous assurer que la refactorisation ne modifie pas le comportement attendu du code.
• Après la correction de bugs : implémentez des tests unitaires sur les bugs qui ont été résolus pour éviter qu'ils ne se reproduisent à l'avenir et pour vous assurer que les corrections n'ont pas altéré d'autres fonctionnalités du software.
• Avant et pendant l'intégration : effectuez des tests unitaires avant de fusionner les modifications dans le code principal et de les incorporer dans votre pipeline d'intégration continue (CI). Cela permet d'éviter que le nouveau code introduise des erreurs et aide à maintenir la stabilité du code de base.

Pyramide du test software

Le test unitaire réalisé dès le début et tout au long du processus de développement du software permet d'améliorer la qualité du code. Cependant, le test unitaire n’est qu'un élément d'une stratégie globale. La pyramide du test software illustre les différents niveaux de tests, à savoir le test unitaire, le test d'intégration et le test système, en mettant en évidence leur granularité et leur fréquence. Cette pyramide fournit une approche structurée de la gestion et de la hiérarchisation des efforts de test, en mettant l'accent sur l'équilibre nécessaire pour obtenir une qualité optimale de software.

Les caractéristiques de ces types de tests sont les suivantes :

• Le test unitaire, à la base de la pyramide, est le plus granulaire et est exécuté fréquemment. Les tests unitaires sont généralement de petite envergure et donc plus rapides et moins coûteux à écrire et à exécuter. Ils peuvent être implémentés rapidement dans processus de développement, ce qui permet d'obtenir un retour d'information immédiat sur le fonctionnement des différents composants.
• Le test d'intégration, situé au milieu de la pyramide, se concentre sur la vérification des interactions entre les différents composants ou systèmes. Les tests d'intégration sont légèrement plus complexes et plus chronophages que les tests unitaires, mais ils sont essentiels pour garantir que les composants intégrés fonctionnent ensemble comme prévu.
• Le test système, au sommet de la pyramide, évalue l'ensemble de l'application. Les tests système sont plus complets et nécessitent plus de ressources. Ils sont généralement effectués plus tard dans le cycle de développement afin de vérifier que le système complet répond aux exigences spécifiées.

La pyramide souligne l'importance d'avoir plus de tests de bas niveau, tels que les tests unitaires, et moins de tests de haut niveau. Une approche équilibrée vise à réaliser environ 70 % de tests unitaires, 20 % de tests d'intégration et 10 % de tests système à la fin du projet. Cette stratégie garantit une base solide constituée de code fiable, ce qui réduit la probabilité que des problèmes émergent lors des phases de test de plus haut niveau.

Autres types de test software

Outre la granularité et la fréquence des tests représentés dans la pyramide du test software, il existe plusieurs types de méthodes de test, chacune ayant des objectifs spécifiques en fonction des résultats escomptés. Il existe une différence essentielle entre les tests fonctionnels et les tests non fonctionnels :

• Les tests fonctionnels se concentrent sur la vérification de la fonctionnalité et du comportement du software. Par exemple, les smoke tests valident les fonctionnalités de base, et les tests de régression vérifient que les nouvelles modifications du code n'altèrent pas les fonctionnalités existantes.
• Les tests non fonctionnels évaluent d'autres aspects critiques du software, tels que la facilité d'utilisation, la sécurité et la stabilité. Les tests de performance, le type le plus courant de test non fonctionnel, évaluent le fonctionnement du software dans des conditions spécifiques, telles que la charge et les contraintes.

L'utilisation de tests fonctionnels et non fonctionnels permet de s'assurer que le software fonctionne correctement et répond aux normes de qualité.

Le test unitaire avec MATLAB

Le test du code fait partie intégrante du développement d'un software de qualité. MATLAB^® fournit un framework de test unitaire robuste et intégré qui vous permet d'écrire des tests unitaires et de surveiller les régressions dans les fonctionnalités du code. Le framework prend en charge l'écriture des tests à l'aide de classes, ce qui vous permet de structurer vos tests de manière logique. En outre, vous pouvez exécuter et analyser les résultats des tests.

Tests unitaires basés sur les classes

Dans cette approche, vous définissez les tests comme des méthodes au sein d'une classe. MATLAB peut générer un modèle générique, et MATLAB Test™ peut générer un test spécifique pour votre code. Cette approche vous permet de tester des scripts et des fonctions dans vos méthodes de test, en combinant l'avantage de la programmation orientée objet avec la flexibilité de tester différents types de code. Cet exemple illustre l'écriture de tests unitaires basés sur des classes.

Exécution de tests

Après avoir enregistré le fichier de test, vous pouvez exécuter le test à partir de la barre d'outils MATLAB. Vous pouvez également utiliser la fonction runtests ou l'application MATLAB Test Browser app pour exécuter des tests, visualiser les résultats et débugger les échecs de manière interactive.

Analyse des résultats de tests

MATLAB fournit des résumés, des rapports détaillés et une couverture de code pour analyser votre code source.

Pour des fonctionnalités plus avancées, MATLAB Test propose des outils supplémentaires qui améliorent le processus de test, telles que la génération automatisée des tests, la gestion améliorée des tests, l'intégration avec les systèmes CI/CD, la couverture de code avancée et un tableau de bord de la qualité. En savoir plus sur l'analyse des résultats des tests.

Exemple de test unitaire dans MATLAB

Cet exemple montre comment effectuer le test unitaire sur une simple fonction fibonacci. Cette fonction calcule la suite de Fibonacci jusqu'à un nombre spécifié (n). Pour valider son exactitude, nous fournissons des exemples d'entrées, et le test unitaire vérifie si la sortie calculée correspond à la sortie attendue pour l'entrée donnée. Si les résultats correspondent, le test est réussi ; dans le cas contraire, il échoue.

function x = fibonacci (n) 
% Generate the first n Fibonacci numbers
n=6;
x = ones (1,n);
for ii = 3:n;
      x(ii) = x(ii - 1) + x(ii - 2);
end

end

% This is an autogenerated sample test for file fibonacci.m
classdef test fibonacci < matlab.unittest.TestCase

    methods (Test)

        function test_fibonacci (testCase)
        % Specify the input (s) of
        % fibonacci
        n = 6;

        % Specify the expected output(s) of
        % fibonacci
        expected_x = [1, 1, 2, 3, 5, 8];

        % Exercise the function fibonacci
        actual_x = fibonacci(n);

        testCase.verifyEqual(actual_x,expected_x);

        end
    end
end