NodeJS

Appearance

Les Spies ​

Les "spies" dans Vitest sont des fonctions qui vous permettent de surveiller l'exécution d'autres fonctions, sans en modifier le comportement. Cela est particulièrement utile pour les tests où vous souhaitez vérifier si une fonction a été appelée, combien de fois elle a été appelée, avec quels arguments, et d'autres comportements similaires. Voyons comment utiliser les spies dans Vitest.

Fonctionnalité de Base des Spies ​

Un spy dans Vitest (et dans d'autres frameworks de test tels que Jest) est une fausse fonction (mock function) qui vous permet d'observer les interactions avec une fonction réelle. Les cas d'utilisation typiques incluent :

  • Vérifier si une fonction a été appelée : Vous pouvez vérifier si une fonction a été appelée pendant le test.
  • Vérifier les arguments d'appel : Vous pouvez inspecter les arguments avec lesquels une fonction a été appelée.
  • Compter le nombre d'appels : Vous pouvez savoir combien de fois une fonction a été appelée.

Comment Utiliser les Spies dans Vitest ​

Dans Vitest, vous pouvez créer un spy en utilisant vi.fn(). Voici quelques exemples :

Création d'un Spy ​

javascript
import { vi } from 'vitest';

const spyFunction = vi.fn();
import { vi } from 'vitest';

const spyFunction = vi.fn();

Vérifier si le Spy a été Appelé ​

javascript
spyFunction();
expect(spyFunction).toHaveBeenCalled();
spyFunction();
expect(spyFunction).toHaveBeenCalled();

Vérifier le Nombre de Fois que le Spy a été Appelé ​

javascript
spyFunction();
spyFunction();
expect(spyFunction).toHaveBeenCalledTimes(2);
spyFunction();
spyFunction();
expect(spyFunction).toHaveBeenCalledTimes(2);

Vérifier les Arguments d'Appel du Spy ​

javascript
spyFunction('arg1', 'arg2');
expect(spyFunction).toHaveBeenCalledWith('arg1', 'arg2');
spyFunction('arg1', 'arg2');
expect(spyFunction).toHaveBeenCalledWith('arg1', 'arg2');

Utilisation Avancée des Spies ​

Les spies peuvent également être utilisés pour "espionner" des méthodes existantes d'un objet. Par exemple, si vous voulez espionner une méthode d'une instance de classe sans changer son comportement :

javascript
class MyClass {
  myMethod() {
    // ...quelque chose...
  }
}

const instance = new MyClass();
const spy = vi.spyOn(instance, 'myMethod');
instance.myMethod();

expect(spy).toHaveBeenCalled();
class MyClass {
  myMethod() {
    // ...quelque chose...
  }
}

const instance = new MyClass();
const spy = vi.spyOn(instance, 'myMethod');
instance.myMethod();

expect(spy).toHaveBeenCalled();

Après avoir fini de tester, vous devez restaurer le comportement original de la méthode :

javascript
spy.mockRestore();
spy.mockRestore();