Maison > interface Web > js tutoriel > Comment simuler efficacement des fonctions au sein d'un même module à l'aide de Jest ?

Comment simuler efficacement des fonctions au sein d'un même module à l'aide de Jest ?

DDD
Libérer: 2024-12-16 02:25:14
original
949 Les gens l'ont consulté

How to Effectively Mock Functions Within the Same Module Using Jest?

Fonctions moqueuses dans le même module à l'aide de Jest

Lorsque l'on se moque de fonctions dans le même module, il est crucial de comprendre les limites de la moquerie par défaut de Jest mécanisme.

Problème :

Importer le module et se moquer directement de sa fonction exportée, comme dans l'exemple ci-dessous, peut conduire à un comportement inattendu.

// module.js
export function bar() { return 'bar'; }
export function foo() { return `I am foo. bar is ${bar()}`; }

// module.test.js
import * as module from '../src/module';

describe('module', () => {
  let barSpy;

  beforeEach(() => {
    barSpy = jest.spyOn(module, 'bar').mockImplementation(jest.fn());
  });

  it('foo', () => {
    module.bar.mockReturnValue('fake bar');
    expect(module.foo()).toEqual('I am foo. bar is fake bar');
    // Fails: Expected "I am foo. bar is fake bar" but received "I am foo. bar is bar"
  });
});
Copier après la connexion

Explication :

Dans l'exemple ci-dessus, foo effectue un appel direct au fonction de barre d'origine pendant le temps d'importation. Même si barSpy est correctement mis à jour lors de la configuration du test, foo fait toujours référence à la fonction bar non simulée, ce qui entraîne une sortie incorrecte.

Solution 1 :

Importer le module dans son propre fichier de code :

Pour contourner ce problème, le module peut être importé dans son propre fichier de code, garantissant ainsi que toutes les entités exportées sont importées de la même instance.

// module.js
export function bar() { return 'bar'; }
export function foo() { return `I am foo. bar is ${thisModule.bar()}`; }

// module.test.js
import * as module from './module';

describe('module', () => {
  it('foo', () => {
    spyOn(module, 'bar').and.returnValue('fake bar');
    expect(module.foo()).toEqual('I am foo. bar is fake bar');
  });
});
Copier après la connexion

Dans cet exemple modifié, foo accède désormais à bar via l'instance importée module.bar, permettant une moquerie facile.

Solution 2 :

Se moquer manuellement du Importations :

Alternativement, les importations peuvent être simulées manuellement dans la configuration de test, créant une nouvelle instance du module isolée de la version non simulée.

// module.test.js
jest.mock('../src/module');
const * as mockedModule = require('../src/module');

describe('module', () => {
  beforeEach(() => {
    mockedModule.bar.mockImplementation(jest.fn());
  });

  it('foo', () => {
    mockedModule.bar.mockReturnValue('fake bar');
    expect(mockedModule.foo()).toEqual('I am foo. bar is fake bar');
  });
});
Copier après la connexion

Dans ce approche, l'instance simulée mockedModule est utilisée pour les tests, empêchant ainsi les interférences des importations non simulées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal