Comment simuler des fonctions dans le même module en utilisant Jest ?

Question

Quelle est la meilleure façon de simuler correctement l'exemple suivant ?

Le problème est qu'après le temps d'importation, foo conserve la référence à l'original non moqué bar .

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

    afterEach(() => {
        barSpy.mockRestore();
    });

    it('foo', () => {
        console.log(jest.isMockFunction(module.bar)); // outputs true

        module.bar.mockReturnValue('fake bar');

        console.log(module.bar()); // outputs 'fake bar';

        expect(module.foo()).toEqual('I am foo. bar is fake bar');
        /**
         * does not work! we get the following:
         *
         *  Expected value to equal:
         *    "I am foo. bar is fake bar"
         *  Received:
         *    "I am foo. bar is bar"
         */
    });
});

Je pourrais changer :

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

à :

export function foo () {
    return `I am foo. bar is ${exports.bar()}`;
}

mais c'est assez laid à mon avis de le faire partout.

Answer 1

Une autre solution consiste à importer le module dans son propre fichier de code et à utiliser l'instance importée de toutes les entités exportées. Voici comment procéder :

import * as thisModule from './module';

export function bar () {
    return 'bar';
}

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

Se moquer maintenant bar est très facile, car foo utilise également l'instance exportée de bar :

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

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

L'importation du module dans son propre code semble étrange, mais grâce à la prise en charge des importations cycliques par ES6, cela fonctionne très bien.

Answer 2

Le problème semble être lié à la manière dont vous envisagez de résoudre la question de la portée de la barre.

D'une part, en module.js vous exportez deux fonctions (au lieu d'un objet contenant ces deux fonctions). En raison de la manière dont les modules sont exportés, la référence au conteneur des éléments exportés est exports comme vous l'avez mentionné.

D'autre part, vous gérez votre exportation (que vous avez aliasée module ) comme un objet contenant ces fonctions et essayant de remplacer l'une de ses fonctions (la barre de fonction).

Si vous regardez de près votre implémentation de foo, vous tenez en fait une référence fixe à la fonction bar.

Lorsque vous pensez avoir remplacé la fonction bar par une nouvelle, vous avez en fait remplacé la copie de référence dans la portée de votre module.test.js.

Pour que foo utilise effectivement une autre version de bar, deux possibilités s'offrent à vous :

1. Dans module.js, exportez une classe ou une instance contenant les méthodes foo et bar :

   Module.js :

   export class MyModule {
     function bar () {
       return 'bar';
     }
   
     function foo () {
       return `I am foo. bar is ${this.bar()}`;
     }
   }

   Notez l'utilisation de cette dans la méthode foo.

   Module.test.js :

   import { MyModule } from '../src/module'
   
   describe('MyModule', () => {
     //System under test :
     const sut:MyModule = new MyModule();
   
     let barSpy;
   
     beforeEach(() => {
         barSpy = jest.spyOn(
             sut,
             'bar'
         ).mockImplementation(jest.fn());
     });
   
     afterEach(() => {
         barSpy.mockRestore();
     });
   
     it('foo', () => {
         sut.bar.mockReturnValue('fake bar');
         expect(sut.foo()).toEqual('I am foo. bar is fake bar');
     });
   });

2. Comme vous l'avez dit, réécrivez la référence globale dans le fichier global exports contenant. Cette méthode n'est pas recommandée, car vous risquez d'introduire des comportements bizarres dans d'autres tests si vous ne réinitialisez pas correctement les exportations à leur état initial.

Answer 3

Par ailleurs, la solution que j'ai retenue est d'utiliser l'injection de dépendance en définissant un argument par défaut.

Je changerais donc

export function bar () {
    return 'bar';
}

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

a

export function bar () {
    return 'bar';
}

export function foo (_bar = bar) {
    return `I am foo. bar is ${_bar()}`;
}

Il ne s'agit pas d'une modification radicale de l'API de mon composant, et je peux facilement remplacer la barre dans mon test en procédant comme suit

import { foo, bar } from '../src/module';

describe('module', () => {
    it('foo', () => {
        const dummyBar = jest.fn().mockReturnValue('fake bar');
        expect(foo(dummyBar)).toEqual('I am foo. bar is fake bar');
    });
});

Cela a aussi l'avantage de conduire à un code de test un peu plus agréable :)

Answer 4

J'ai eu le même problème et en raison des normes de linting du projet, la définition d'une classe ou la réécriture des références dans le fichier exports n'étaient pas des options approuvables par la revue de code, même si elles n'étaient pas empêchées par les définitions de linting. Ce que j'ai trouvé comme option viable est d'utiliser l'option babel-rewire-plugin qui est beaucoup plus propre, du moins en apparence. J'ai trouvé cette méthode dans un autre projet auquel j'avais accès, mais j'ai remarqué qu'elle figurait déjà dans une réponse à une question similaire que j'ai mise en lien. ici . Il s'agit d'un extrait adapté à cette question (et sans utiliser d'espions) fourni à partir de la réponse liée pour référence (j'ai également ajouté des points-virgules en plus de supprimer les espions parce que je ne suis pas un païen) :

import __RewireAPI__, * as module from '../module';

describe('foo', () => {
  it('calls bar', () => {
    const barMock = jest.fn();
    __RewireAPI__.__Rewire__('bar', barMock);

    module.foo();

    expect(bar).toHaveBeenCalledTimes(1);
  });
});

https://stackoverflow.com/a/45645229/6867420

Answer 5

Si vous définissez vos exportations, vous pouvez alors faire référence à vos fonctions en tant que partie de l'objet d'exportation. Vous pouvez alors écraser les fonctions dans vos objets fantaisie individuellement. Cela est dû au fait que l'importation fonctionne comme une référence et non comme une copie.

module.js :

exports.bar () => {
    return 'bar';
}

exports.foo () => {
    return `I am foo. bar is ${exports.bar()}`;
}

module.test.js :

describe('MyModule', () => {

  it('foo', () => {
    let module = require('./module')
    module.bar = jest.fn(()=>{return 'fake bar'})

    expect(module.foo()).toEqual('I am foo. bar is fake bar');
  });

})