Logo

Utiliser les spies de Jest pour surveiller les appels de fonctions

Introduction

Lors de l'écriture de tests unitaires, il est souvent nécessaire de vérifier comment les fonctions sont appelées. Les spies de Jest offrent un moyen précis de surveiller et de valider les interactions entre différentes parties de votre code.

Cet article explore comment utiliser les spies Jest pour analyser les appels de fonctions pendant vos tests.

1. Création de spies avec jest.fn()

La méthode `jest.fn()` permet de créer des spies qui enregistrent les détails de leurs appels, comme le nombre de fois où elles sont appelées, les arguments passés, et les valeurs de retour.

test('spy sur une fonction simple', () => {
  const maFonction = jest.fn();
  
  maFonction('hello', 42);
  
  expect(maFonction).toHaveBeenCalled();
  expect(maFonction).toHaveBeenCalledWith('hello', 42);
});

2. Vérification des appels de fonction

Les spies permettent de vérifier précisément comment une fonction a été utilisée, en comptant les appels ou en inspectant les arguments.

function traiterDonnees(callback) {
  const donnees = [1, 2, 3];
  donnees.forEach(callback);
}

test('vérification des appels de callback', () => {
  const mockCallback = jest.fn();
  
  traiterDonnees(mockCallback);
  
  expect(mockCallback).toHaveBeenCalledTimes(3);
  expect(mockCallback).toHaveBeenNthCalledWith(1, 1);
  expect(mockCallback).toHaveBeenNthCalledWith(2, 2);
});

3. Espionnage de méthodes d'objet

Vous pouvez facilement espionner des méthodes d'objets pour vérifier leur comportement sans modifier leur implémentation originale.

class Utilisateur {
  enregistrer(donnees) {
    // Logique d'enregistrement
    return true;
  }
}

test('spy sur une méthode de classe', () => {
  const utilisateur = new Utilisateur();
  const spy = jest.spyOn(utilisateur, 'enregistrer');
  
  utilisateur.enregistrer({ nom: 'Jean' });
  
  expect(spy).toHaveBeenCalledWith({ nom: 'Jean' });
  expect(spy).toHaveBeenCalledTimes(1);
});

4. Bonnes pratiques

  • Utiliser des spies pour vérifier les interactions entre composants
  • Ne pas trop complexifier vos tests avec des spies
  • Restaurer les implémentations originales après les tests
  • Combiner les spies avec d'autres assertions Jest

Exemple complet : Test de service d'authentification

class ServiceAuthentification {
  constructor(api) {
    this.api = api;
  }

  connecter(identifiant, motDePasse) {
    return this.api.authentifier(identifiant, motDePasse);
  }
}

test('service authentification', () => {
  const mockApi = {
    authentifier: jest.fn().mockReturnValue(true)
  };
  
  const service = new ServiceAuthentification(mockApi);
  const resultat = service.connecter('utilisateur', 'mdp');
  
  expect(mockApi.authentifier).toHaveBeenCalledWith('utilisateur', 'mdp');
  expect(resultat).toBe(true);
});

Conclusion

Les spies Jest vous permettent de regarder précisément comment vos fonctions interagissent. En maîtrisant ces techniques, vous rendrez vos tests plus robustes et informatifs.

Logo