Comment puis-je simuler une importation de module ES6 à l'aide de Jest?

Je commence à penser que ce n'est pas possible, mais je veux quand même demander.

Je veux tester qu'un de mes modules ES6 appelle un autre module ES6 d'une manière particulière. Avec Jasmine, c'est super facile -

Le code de l'application:

// myModule.js
import dependency from './dependency';

export default (x) => {
  dependency.doSomething(x * 2);
}

Et le code de test:

//myModule-test.js
import myModule from '../myModule';
import dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    spyOn(dependency, 'doSomething');

    myModule(2);

    expect(dependency.doSomething).toHaveBeenCalledWith(4);
  });
});

Quel est l'équivalent avec Jest? J'ai l'impression que c'est une chose si simple à vouloir faire, mais je me suis arraché les cheveux en essayant de le comprendre.

Le plus proche que je suis venu est de remplacer le imports par le requires et de les déplacer dans les tests / fonctions. Je ne veux pas faire quoi que ce soit.

// myModule.js
export default (x) => {
  const dependency = require('./dependency'); // yuck
  dependency.doSomething(x * 2);
}

//myModule-test.js
describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    jest.mock('../dependency');

    myModule(2);

    const dependency = require('../dependency'); // also yuck
    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

Pour les points bonus, je serais ravi de faire fonctionner le tout lorsque la fonction à l'intérieur dependency.jsest une exportation par défaut. Cependant, je sais que l'espionnage des exportations par défaut ne fonctionne pas dans Jasmine (ou du moins je ne pourrais jamais le faire fonctionner), donc je n'espère pas que cela soit possible dans Jest.

J'ai pu résoudre ce problème en utilisant un hack impliquant import *. Cela fonctionne même pour les exportations nommées et par défaut!

Pour une exportation nommée:

// dependency.js
export const doSomething = (y) => console.log(y)

// myModule.js
import { doSomething } from './dependency';

export default (x) => {
  doSomething(x * 2);
}

// myModule-test.js
import myModule from '../myModule';
import * as dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    dependency.doSomething = jest.fn(); // Mutate the named export

    myModule(2);

    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

Ou pour une exportation par défaut:

// dependency.js
export default (y) => console.log(y)

// myModule.js
import dependency from './dependency'; // Note lack of curlies

export default (x) => {
  dependency(x * 2);
}

// myModule-test.js
import myModule from '../myModule';
import * as dependency from '../dependency';

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    dependency.default = jest.fn(); // Mutate the default export

    myModule(2);

    expect(dependency.default).toBeCalledWith(4); // Assert against the default
  });
});

Comme Mihai Damian l'a souligné à juste titre ci-dessous, cela modifie l'objet du module dependency, et il va donc `` fuir '' vers d'autres tests. Donc, si vous utilisez cette approche, vous devez stocker la valeur d'origine, puis la rétablir à nouveau après chaque test. Pour ce faire facilement avec Jest, utilisez la méthode spyOn () au lieu de jest.fn()car elle prend en charge la restauration facile de sa valeur d'origine, évitant ainsi la «fuite» mentionnée précédemment.

Vous devez vous moquer du module et définir l'espion par vous-même:

import myModule from '../myModule';
import dependency from '../dependency';
jest.mock('../dependency', () => ({
  doSomething: jest.fn()
}))

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    myModule(2);
    expect(dependency.doSomething).toBeCalledWith(4);
  });
});

Pour simuler une exportation par défaut du module de dépendance ES6 à l'aide de jest:

import myModule from '../myModule';
import dependency from '../dependency';

jest.mock('../dependency');

// If necessary, you can place a mock implementation like this:
dependency.mockImplementation(() => 42);

describe('myModule', () => {
  it('calls the dependency once with double the input', () => {
    myModule(2);

    expect(dependency).toHaveBeenCalledTimes(1);
    expect(dependency).toHaveBeenCalledWith(4);
  });
});

Les autres options n'ont pas fonctionné pour mon cas.

Ajout de plus à la réponse d'Andreas. J'ai eu le même problème avec le code ES6 mais je ne voulais pas muter les importations. Cela semblait bizarre. Alors j'ai fait ça

import myModule from '../myModule';
import dependency from '../dependency';
jest.mock('../dependency');

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    myModule(2);
  });
});

Et ajouté dependency.js dans le dossier "__ mocks __" parallèle à dependency.js. Cela a fonctionné pour moi. De plus, cela m'a donné la possibilité de renvoyer des données appropriées à partir d'une implémentation fictive. Assurez-vous de donner le chemin correct au module que vous souhaitez simuler.

Avance rapide jusqu'en 2020, j'ai trouvé ce lien comme la solution. en utilisant uniquement la syntaxe du module ES6 https://remarkablemark.org/blog/2018/06/28/jest-mock-default-named-export/

// esModule.js
export default 'defaultExport';
export const namedExport = () => {};

// esModule.test.js
jest.mock('./esModule', () => ({
  __esModule: true, // this property makes it work
  default: 'mockedDefaultExport',
  namedExport: jest.fn(),
}));

import defaultExport, { namedExport } from './esModule';
defaultExport; // 'mockedDefaultExport'
namedExport; // mock function

Une chose que vous devez également savoir (ce qui m'a pris du temps à comprendre) est que vous ne pouvez pas appeler jest.mock () dans le test; vous devez l'appeler au niveau supérieur du module. Cependant, vous pouvez appeler mockImplementation () dans des tests individuels si vous souhaitez configurer différents mocks pour différents tests.

La question est déjà répondue mais vous pouvez la résoudre comme ceci:

dependency.js

const doSomething = (x) => x
export default doSomething;

myModule.js:

import doSomething from "./dependency";

export default (x) => doSomething(x * 2);

myModule.spec.js:

jest.mock('../dependency');
import doSomething from "../dependency";
import myModule from "../myModule";

describe('myModule', () => {
  it('calls the dependency with double the input', () => {
    doSomething.mockImplementation((x) => x * 10)

    myModule(2);

    expect(doSomething).toHaveBeenCalledWith(4);
    console.log(myModule(2)) // 40
  });
});

J'ai résolu cela d'une autre manière. Disons que vous avez votre dependency.js

export const myFunction = () => { }

Je crée en plus un fichier depdency.mock.js avec le contenu suivant:

export const mockFunction = jest.fn();

jest.mock('dependency.js', () => ({ myFunction: mockFunction }));

et dans le test, avant d'importer le fichier qui a la dépendance que j'utilise:

import { mockFunction } from 'dependency.mock'
import functionThatCallsDep from './tested-code'

it('my test', () => {
    mockFunction.returnValue(false);

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})