Comment simuler efficacement des fonctions au sein d'un même module à l'aide de 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"
  });
});

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');
  });
});

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');
  });
});

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!