Test unitaire avec Jest

npx jest

ou si vous avez configuré Jest pour être exécuté via un script npm, vous pouvez simplement exécuter :

npm test

Cela exécutera tous les fichiers de test dans votre projet avec Jest.

Conseils de réflexion pour les tests

Voici quelques conseils de réflexion pour réaliser des tests efficaces avec Jest :

1. Identifiez les cas limites :

Avant d'écrire des tests, identifiez les cas limites ou les situations spéciales auxquelles votre fonction ou votre application pourrait être confrontée. Ces cas comprennent souvent des valeurs extrêmes, des valeurs nulles, des entrées incorrectes, etc. Assurez-vous que vos tests couvrent ces cas limites pour garantir le bon fonctionnement de votre code dans toutes les situations.

2. Utilisez des assertions appropriées :

Choisissez les assertions appropriées pour vos tests en fonction du comportement attendu de votre fonction. Jest offre une variété d'assertions telles que expect, toEqual, toBeTruthy, toContain, etc. Choisissez celle qui correspond le mieux à ce que vous voulez tester.

3. Organisez vos tests de manière logique :

Organisez vos tests de manière logique en regroupant les tests qui vérifient le comportement similaire de votre fonction ou de votre application. Cela rend vos tests plus faciles à lire, à comprendre et à maintenir. Vous pouvez utiliser les fonctions describe et test de Jest pour organiser vos tests en suites logiques.

4. Utilisez des mocks pour isoler les dépendances :

Lorsque vous testez une fonction qui dépend d'autres fonctions ou modules, utilisez des mocks pour isoler ces dépendances. Cela vous permet de tester la fonction de manière indépendante et de simuler différents scénarios sans affecter les autres parties de votre application.

Les mocks sont des outils précieux lorsqu'il s'agit de tester des fonctions ou des modules qui dépendent d'autres parties de votre application. En isolant ces dépendances, vous pouvez tester le comportement de la fonction ou du module cible de manière indépendante, sans être affecté par le comportement réel des dépendances.

voici un exemple utilisant des mocks pour tester une fonction qui effectue des opérations mathématiques simples telles que l'addition, la multiplication, la soustraction et la division. Nous allons tester une fonction calculate qui prend deux nombres et une opération en tant qu'arguments, puis renvoie le résultat de l'opération.

Voici notre fichier mathOperations.js qui contient la fonction calculate :

// mathOperations.js

function calculate(a, b, operation) {
  switch (operation) {
    case 'addition':
      return a + b;
    case 'multiplication':
      return a * b;
    case 'soustraction':
      return a - b;
    case 'division':
      if (b === 0) {
        throw new Error("Division par zéro est impossible.");
      }
      return a / b;
    default:
      throw new Error("Opération non valide.");
  }
}

module.exports = calculate;

Maintenant, nous allons écrire des tests pour cette fonction en utilisant des mocks pour simuler les opérations mathématiques. Voici notre fichier de test mathOperations.test.js :

// mathOperations.test.js

const calculate = require('./mathOperations');

// Créer un mock pour la fonction division
jest.mock('./mathOperations', () => {
  return {
    __esModule: true,
    default: jest.fn(),
  };
});

// Définir le comportement du mock pour l'addition
calculate.mockImplementation((a, b, operation) => {
  switch (operation) {
    case 'addition':
      return a + b;
    case 'multiplication':
      return a * b;
    case 'soustraction':
      return a - b;
    case 'division':
      return a / b;
    default:
      throw new Error("Opération non valide.");
  }
});

// Test de la fonction calculate pour l'addition
test('Calcul de l\'addition', () => {
  expect(calculate(2, 3, 'addition')).toBe(5);
});

// Test de la fonction calculate pour la multiplication
test('Calcul de la multiplication', () => {
  expect(calculate(2, 3, 'multiplication')).toBe(6);
});

// Test de la fonction calculate pour la soustraction
test('Calcul de la soustraction', () => {
  expect(calculate(5, 3, 'soustraction')).toBe(2);
});

// Test de la fonction calculate pour la division
test('Calcul de la division', () => {
  expect(calculate(6, 2, 'division')).toBe(3);
});

// Test de la fonction calculate pour la division par zéro
test('Division par zéro', () => {
  expect(() => calculate(6, 0, 'division')).toThrow();
});

Dans cet exemple :

• Nous utilisons jest.mock pour créer un mock pour notre module mathOperations.
• Nous utilisons calculate.mockImplementation pour définir le comportement du mock. Dans ce cas, nous définissons le mock pour qu'il imite le comportement de notre fonction calculate, mais sans effectuer réellement les opérations mathématiques.
• Ensuite, nous écrivons des tests pour vérifier le bon fonctionnement de notre fonction calculate pour différentes opérations mathématiques.

Ainsi, nous testons la fonction calculate de manière isolée en utilisant des mocks pour simuler les opérations mathématiques, ce qui rend nos tests plus fiables et indépendants de la logique interne de ces opérations.

5. Écrivez des tests clairs et descriptifs :

Écrivez des tests clairs et descriptifs qui expliquent ce que vous testez, comment vous le testez et pourquoi c'est important. Un bon test devrait être compréhensible par toute personne lisant votre code, y compris vous-même dans le futur. Utilisez des noms de tests significatifs et des commentaires si nécessaire pour expliquer le but de chaque test.

6. Exécutez vos tests régulièrement :

Exécutez vos tests régulièrement pour vous assurer que votre code continue de fonctionner comme prévu à mesure que vous apportez des modifications. Intégrez vos tests dans votre processus de développement et exécutez-les automatiquement à chaque fois que vous effectuez des modifications importantes dans votre code.

En suivant ces conseils de réflexion, vous serez en mesure de rédiger des tests efficaces avec Jest qui garantissent la qualité et la fiabilité de votre code JavaScript.

Conclusion

Dans ce cours, nous avons appris à utiliser Jest pour tester des fonctions mathématiques simples telles que l'addition, la soustraction et la division. Jest offre une syntaxe simple et des fonctionnalités puissantes pour écrire des tests JavaScript efficaces. Continuez à pratiquer et à explorer les fonctionnalités avancées de Jest pour améliorer vos compétences en matière de tests JavaScript.