Maîtriser les matchers Jest : La clé pour des tests plus précis

🎯 Introduction aux Matchers

Qu'est-ce qu'un Matcher ?

Un matcher est une fonction qui permet de tester une valeur ou un comportement attendu dans un test. Avec Jest, vous pouvez utiliser des matchers pour comparer les résultats des fonctions, des objets ou d'autres expressions du code avec les résultats attendus. Les matchers rendent les tests plus expressifs et lisibles, et permettent de tester des cas complexes de manière précise et claire.

Exemple de base

L'utilisation d'un matcher se fait à l'aide de la fonction expect(), suivie d'un matcher. Par exemple, pour tester qu'une addition donne le bon résultat, vous pouvez écrire :

expect(3 + 2).toBe(5);

Dans cet exemple, la fonction expect(3 + 2) crée une attente, et le matcher toBe s'assure que la valeur retournée est bien 5. Si ce n'est pas le cas, Jest signalera une erreur.

🛠️ Matchers courants

Tester l'égalité stricte

Le matcher toBe est utilisé pour tester l'égalité stricte de valeurs primitives, comme des nombres ou des chaînes de caractères. Cependant, il ne compare pas les objets ou les tableaux de manière profonde. Voici un exemple avec des variables :

const result = 10 + 2;
expect(result).toBe(12);  // Vérifie que la constante result est bien égale à 12

const greeting = 'hello world';
expect(greeting).toBe('hello world');  // Vérifie que greeting contient bien la chaîne 'hello world'

Ces tests comparent des valeurs simples ou le résultat de calculs. Pour des comparaisons plus complexes (par exemple avec des objets ou des tableaux), il est préférable d'utiliser le matcher toEqual.

Tester des objets et des tableaux

Si vous souhaitez tester des objets ou des tableaux, il faut utiliser le matcher toEqual. Ce matcher effectue une comparaison profonde, en vérifiant que les propriétés des objets ou les éléments des tableaux sont identiques. Exemple :

const user = { name: 'John', age: 30 };
expect(user).toEqual({ name: 'John', age: 30 });  // Vérifie que les objets sont identiques

Vérifier des valeurs spécifiques

Jest propose des matchers pour tester des valeurs spécifiques comme toBeNull() et toBeUndefined(), qui permettent respectivement de tester si une valeur est null ou undefined.

const value = null;
expect(value).toBeNull();       // Vérifie que la valeur est null

const name = undefined;
expect(name).toBeUndefined();   // Vérifie que la valeur est undefined

Tester si une valeur est "vraie" ou "fausse"

En JavaScript, certaines valeurs sont considérées comme "vraies" ou "fausses" lorsqu'elles sont évaluées dans un contexte booléen. Les matchers toBeTruthy() et toBeFalsy() permettent de tester ces valeurs. Voici un exemple :

const emptyArray = [];
expect(emptyArray).toBeFalsy();  // Un tableau vide est évalué comme 'faux'

const nonEmptyArray = [1, 2];
expect(nonEmptyArray).toBeTruthy();  // Un tableau non vide est évalué comme 'vrai'

const number = 0;
expect(number).toBeFalsy();  // 0 est évalué comme 'faux'

const str = 'non-empty string';
expect(str).toBeTruthy();  // Une chaîne non vide est évaluée comme 'vraie'

Ces vérifications sont utiles lorsque vous souhaitez tester des comportements basés sur des évaluations booléennes implicites en JavaScript. Une valeur est "vraie" si elle est évaluée comme vraie dans une expression booléenne, et "fausse" si elle est évaluée comme fausse.

Tester les promesses

Lorsque vous travaillez avec des fonctions asynchrones, il est important de tester les résultats des promesses. Jest fournit les matchers resolves et rejects pour tester respectivement les cas où une promesse est résolue ou rejetée. Exemple :

test('Test avec une promesse réussie', async () => {
    await expect(Promise.resolve('success')).resolves.toBe('success');
});

test('Test avec une promesse échouée', async () => {
    await expect(Promise.reject('error')).rejects.toBe('error');
});

⚙️ Créer des Matchers Personnalisés

Parfois, les matchers prédéfinis ne suffisent pas. Jest permet de créer des matchers personnalisés pour répondre à des besoins spécifiques. Par exemple, si vous voulez tester si un nombre est pair, vous pouvez créer un matcher personnalisé :

expect.extend({
    toBeEven(received) {
        const pass = received % 2 === 0;
        return pass
            ? { pass: true }
            : { pass: false, message: () => `${received} n'est pas un nombre pair` };
    },
});

Une fois ce matcher créé, vous pouvez l'utiliser comme suit :

expect(4).toBeEven();

Il est également possible de gérer les erreurs. Par exemple, si vous testez un nombre impair, Jest renverra un message d'erreur personnalisé.

🔧 Bonnes pratiques et conseils

Lors de l'écriture de tests avec Jest, il est important de respecter certaines bonnes pratiques :

• Être explicite dans les assertions : il est essentiel de tester des valeurs spécifiques plutôt que de s'appuyer sur des tests implicites de vérité.
• Utiliser les matchers adaptés aux types de données que vous testez.
• Créer des matchers personnalisés pour rendre les tests plus lisibles et éviter la répétition de code.
• Tester les comportements asynchrones à l'aide des matchers resolves et rejects pour les promesses.