Testez qu'une fonction fait ce qu'elle dit

Comprenez l'importance des tests

La programmation consiste à générer un code qui effectue les opérations prévues. Nous avons précédemment traité des erreurs qui devaient être corrigées pendant l'écriture (erreurs de compilation) ainsi que d'autres qui apparaissent pendant l'exécution. Allons plus loin pour nous assurer que vos fonctions marchent correctement et comme prévu. Pour ce faire, vous devez effectuer des tests sur votre code.

Il existe deux moyens de tester vos fonctions :

1. Écrire des fonctions de test

2. Utiliser des processus automatisés

Utilisez des fonctions de test

Les fonctions de test sont un ensemble de fonctions destinées à tester les fonctions principales de l'application. Par exemple, si vous avez une classe qui fait des calculs simples, vous pouvez définir quelque chose comme ceci :

class MathMagiques
{
    public static int Somme(int a, int b)
    {
        return a + b;
    }
    
    public static int Soustraction(int a, int b)
    {
        return a - b;
    }
}

Vous pouvez ensuite écrire une fonction pour la tester :

// Tester la somme
if (MathMagiques.Somme(1, 5) == 6)
{
    Console.WriteLine("La somme est correcte");
}
else
{
    Console.WriteLine("La somme est incorrecte");
}

// Tester la soustraction
if (MathMagiques.Soustraction(10, 8) == 2)
{
    Console.WriteLine("La soustraction est correcte")
}
else
{
    Console.WriteLine("La soustraction est incorrecte");
}

Ce code paraît fonctionnel, vous devriez obtenir des résultats corrects. Supposons maintenant (simple supposition, vraiment 🙂) que vous ayez fait une erreur dans l'implémentation des fonctions de la classe en inversant les nombres  a  et  b  :

class MathMagiques
{
    public static int Somme(int a, int b)
    {
        return b + a;
    }

    public static int Soustraction(int a, int b)
    {
        return b - a;
    }
}

Exécutez ensuite les mêmes tests :

// Tester la somme
if (MathMagiques.Somme(1, 5) == 6)
{
    Console.WriteLine("La somme est correcte");
}
else
{
    Console.WriteLine("La somme est incorrecte");
}

// Tester la soustraction
if (MathMagiques.Soustraction(10, 8) == 2)
{
    Console.WriteLine("La soustraction est correcte");
}
else
{
    Console.WriteLine("La soustraction est incorrecte");
}

Dans cette situation, la fonction  Somme  ne sera pas affectée. Calculer  a + b  ou  b + a  revient au même.

Mais la fonction  Soustraction  va générer un résultat complètement erroné ! 😱

Dans la plupart des cas, les fonctions que vous devrez tester présenteront des comportements plus complexes, mais même avec cet exemple simple, vous pouvez voir qu'il est facile de faire une erreur et qu'il faut effectuer plusieurs tests différents pour la repérer.

En fait, on commet plus facilement des erreurs banales lorsqu'on est trop sûr de soi. Voici un scénario plausible : vous avez écrit votre fonction  Somme  en indiquant  b + a  au lieu de  a + b  . Vous l'avez testée et elle a bien fonctionné ! Vous avez ensuite copié le code de la fonction  Somme  , remplacé  +  par  -  et poursuivi votre développement sans faire d'autre test. Vous étiez sûr et certain que cela fonctionnerait, car la seule différence entre les deux fonctions est l'opérateur mathématique. Malheureusement, ça ne marche pas toujours. C'est pourquoi il est extrêmement important de faire des tests, quelle que soit la méthode que vous utilisez !

Mettez en forme le code de test

Vous créez ici du code auquel les utilisateurs n'auront pas recours dans le déroulement normal de l'application. Par conséquent, il est conseillé de séparer ce code du code principal. Une façon de le faire est de dédier une section d'une classe au test. De cette façon, il peut facilement être repéré et supprimé.

Vous pouvez également placer le code de test dans des fichiers séparés afin qu'ils puissent être repérés et supprimés. Assurez-vous que votre code de test est facilement identifiable. Pour cela, vous pouvez utiliser des mots qui sont naturellement associés aux tests, comme test, tmp, factice, etc. Reprenons notre exemple de calcul pour organiser le code de test en fonctions :

public static void TestSomme()
{
    if (MathMagiques.Somme(1, 5) == 6)
    {
        Console.WriteLine("La somme est correcte");
    }
    else
    {
        Console.WriteLine("La somme est incorrecte");
    }
}

public static void TestSoustraction()
{
    if (MathMagiques.Soustraction(10, 8) == 2)
    {
        Console.WriteLine("La soustraction est correcte");
    }
    else
    {
        Console.WriteLine("La soustraction est incorrecte");
    }
}

Ensuite, il suffit d'appeler les fonctions de test :

// Tester la somme
MathMagiques.TestSomme();
// Tester la soustraction
MathMagiques.TestSoustraction();

Cette approche est utile dans de nombreux cas ; toutefois, à mesure que la complexité de votre projet augmente, ces méthodes deviennent moins fiables et plus longues. Vous pouvez pousser plus loin l'idée de séparer le code de test et le transformer en une application de test à part entière. Cela nous amène à notre prochain sujet : les processus automatisés.

Utilisez les processus automatisés pour vos tests

Les tests peuvent être plus efficaces grâce à des processus automatisés. Des outils dédiés vous permettent de créer une couche de test, c'est-à-dire une toute nouvelle application qui teste l'application principale. L'application de test fonctionne en tandem avec l'application principale pour garantir que la logique de votre programme fonctionne comme prévu.

Il existe deux catégories de tests d'applications :

• Les tests fonctionnels

• Les tests unitaires

Les tests fonctionnels peuvent être programmatiques (automatisés) ou stratégiques (manuels), et sont utilisés pour tester la fonctionnalité complète d'une application.

Les tests unitaires sont des tests programmatiques utilisés pour valider un petit morceau de code, généralement une méthode ou une fonction. Ils sont similaires aux fonctions de test présentées plus haut dans ce chapitre. La différence est qu'ils sont mis en forme et isolés dans une application distincte. Il existe toutefois deux différences caractéristiques.

La première est l'utilisation de techniques de nommage précises, qui énoncent les conditions exactes du test. Dans ce cas, ce sont les arguments que vous testez. Cela transformerait les noms de vos fonctions de test en :

// Tester Somme
public void TestUnPlusCinqEgalSix()
{
}

// Tester Soustraction
public void TestDixMoinsHuitEgalDeux()
{
}

Ici, vous remarquerez également que vous n'avez plus besoin d'utiliser  Somme  ou  Soustraction  pour nommer une fonction de test, car vous avez des noms très spécifiques et clairs qui incluent  Plus  ou  Moins  .

La deuxième différence est qu'au lieu d'afficher la sortie en retour, la fonction lève une exception et génère volontairement une erreur. En C#, vous pouvez utiliser des méthodes prédéfinies. Ainsi, au lieu de réinventer la roue, vous pouvez ajouter une bibliothèque pour profiter de toutes les méthodes et variables qui lui sont associées.

N'oubliez pas qu'écrire des tests est toujours une bonne idée ! 🏆

Testez par vous-même !

Prêt à coder ? Pour accéder à l’exercice, suivez ce lien. 

En résumé 

Dans ce chapitre, vous avez appris un concept central de la programmation : les tests. Ils sont réalisés de deux manières :

• L'utilisation des fonctions de test.

  • Les fonctions de test forment du code temporaire au sein de l'application principale.

  • Cette approche est moins fiable et fonctionne pour les tests rapides dans les petits projets.

• L'utilisation de processus automatisés avec le recours à des outils dédiés.

  • Les tests unitaires sont un exemple populaire de tests automatisés.

  • Les tests automatisés sont mis en œuvre sous la forme d'une autre application qui teste l'application principale.

  • L'application principale et l'application de test vont de pair et se valident mutuellement.