Mocks ​

Les "mocks" dans Vitest sont des outils puissants qui permettent de simuler le comportement de certaines parties de votre code lors des tests. Cela peut être extrêmement utile pour isoler les tests, simuler des scénarios complexes, ou éviter des opérations coûteuses en temps, comme les appels réseau. Voici une explication de ce que sont les mocks et comment les utiliser dans Vitest :

Qu'est-ce qu'un Mock? ​

Un mock est une imitation d'une fonctionnalité réelle dans un environnement de test. Il permet de remplacer une partie du système que vous testez par une version simplifiée qui se comporte comme vous le souhaitez pour le test. Les mocks peuvent retourner des valeurs spécifiques, simuler des erreurs ou simplement enregistrer des informations sur la façon dont ils ont été utilisés.

Utilisation des Mocks dans Vitest ​

1. Mock de Fonctions: Vous pouvez "moquer" (mock) des fonctions pour contrôler leur comportement dans les tests. Cela est particulièrement utile pour les fonctions qui dépendent de ressources externes.

   javascript

   import { it, expect, vi } from 'vitest';
   
   it('mocks a function', () => {
     const mockFn = vi.fn();
     mockFn.mockReturnValue('valeur mockée');
     expect(mockFn()).toBe('valeur mockée');
   });

   import { it, expect, vi } from 'vitest';
   
   it('mocks a function', () => {
     const mockFn = vi.fn();
     mockFn.mockReturnValue('valeur mockée');
     expect(mockFn()).toBe('valeur mockée');
   });

2. Mock de Modules: Vitest permet de "moquer" des modules entiers, ce qui est utile pour les tests de composants qui dépendent de modules externes.

   javascript

   import { describe, it, expect, vi } from 'vitest';
   import * as someModule from './someModule';
   
   vi.mock('./someModule');
   
   describe('mock module test', () => {
     it('uses a mock module', () => {
       someModule.someFunction.mockReturnValue('mocked value');
       expect(someModule.someFunction()).toBe('mocked value');
     });
   });

   import { describe, it, expect, vi } from 'vitest';
   import * as someModule from './someModule';
   
   vi.mock('./someModule');
   
   describe('mock module test', () => {
     it('uses a mock module', () => {
       someModule.someFunction.mockReturnValue('mocked value');
       expect(someModule.someFunction()).toBe('mocked value');
     });
   });

3. Mock de Promesses: Vous pouvez également "moquer" des promesses pour tester des scénarios asynchrones.

   javascript

   it('mocks a promise', async () => {
     const mockAsyncFunction = vi.fn().mockResolvedValue('valeur résolue');
     await expect(mockAsyncFunction()).resolves.toBe('valeur résolue');
   });

   it('mocks a promise', async () => {
     const mockAsyncFunction = vi.fn().mockResolvedValue('valeur résolue');
     await expect(mockAsyncFunction()).resolves.toBe('valeur résolue');
   });

4. Réinitialiser/Restaurer les Mocks: Après avoir utilisé des mocks, vous pouvez les réinitialiser ou les restaurer pour éviter qu'ils n'affectent d'autres tests.

   javascript

   afterEach(() => {
     vi.restoreAllMocks();
   });

   afterEach(() => {
     vi.restoreAllMocks();
   });

Dossier mocks ​

Le dossier __mocks__ est une fonctionnalité souvent utilisée dans des frameworks de test JavaScript tels que Jest, et il peut également être adopté dans d'autres contextes comme avec Vitest, pour organiser et gérer les mocks (simulations) de modules. L'utilisation de ce dossier est particulièrement utile lorsque vous avez besoin de remplacer le comportement par défaut de certains modules externes ou internes pendant vos tests. Voici une explication détaillée de son utilisation :

But du Dossier __mocks__ ​

Le dossier __mocks__ est destiné à stocker des fichiers de mock qui simulent le comportement de modules spécifiques. Lorsque vous exécutez vos tests, le framework de test va chercher dans ce dossier des mocks correspondants aux modules que vous importez dans vos fichiers de test. Si un mock correspondant est trouvé, le framework l'utilisera à la place du module réel.

Comment Utiliser __mocks__ ​

1. Création du Dossier __mocks__ :

   • Placez le dossier __mocks__ au même niveau que le dossier node_modules ou dans le dossier contenant vos modules si vous moquez vos propres modules.
   • Pour mocker un module moduleName, créez un fichier portant le même nom que le module dans le dossier __mocks__. Par exemple, pour mocker axios, créez un fichier axios.js dans __mocks__.

2. Écriture des Mocks :

   • Dans chaque fichier de mock, écrivez l'implémentation mockée du module. Par exemple, si vous moquez axios, vous pouvez simuler les méthodes get, post, etc.
   javascript

   // __mocks__/axios.js
   export default {
     get: jest.fn(() => Promise.resolve({ data: {} })),
     post: jest.fn(() => Promise.resolve({ data: {} })),
     // et ainsi de suite pour les autres méthodes
   };

   // __mocks__/axios.js
   export default {
     get: jest.fn(() => Promise.resolve({ data: {} })),
     post: jest.fn(() => Promise.resolve({ data: {} })),
     // et ainsi de suite pour les autres méthodes
   };

3. Activation des Mocks dans les Tests :

   • Dans vos fichiers de test, vous pouvez dire au framework de test d'utiliser les mocks en appelant des méthodes telles que vi.mock('moduleName').
   • Par exemple, pour mocker axios dans un test :
   javascript

   import { vi } from 'vitest'
   
   vi.mock('axios');

   import { vi } from 'vitest'
   
   vi.mock('axios');