Como posso simular uma importação de módulo ES6 usando o Jest?

Estou começando a pensar que isso não é possível, mas quero perguntar de qualquer maneira.

Quero testar se um dos meus módulos ES6 chama outro módulo ES6 de uma maneira específica. Com Jasmine, isso é super fácil -

O código do aplicativo:

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

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

E o código de teste:

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

Qual é o equivalente com Jest? Eu sinto que isso é uma coisa tão simples de se querer fazer, mas eu tenho arrancado meu cabelo tentando descobrir isso.

O mais próximo que cheguei é substituindo os importpor requires e movendo-os para dentro dos testes / funções. Nenhuma das coisas que eu quero fazer.

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

Para pontos de bônus, eu adoraria fazer a coisa toda funcionar quando a função interna dependency.jsfor uma exportação padrão. No entanto, eu sei que espionar as exportações padrão não funciona no Jasmine (ou pelo menos eu nunca consegui fazê-lo funcionar), então não tenho esperança de que seja possível no Jest também.

Consegui resolver isso usando um hack envolvendo import *. Até funciona para exportações nomeadas e padrão!

Para uma exportação nomeada:

// 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 para uma exportação padrão:

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

Como Mihai Damian apontou corretamente, isso está mudando o objeto do módulo dependencye, portanto, 'vazará' para outros testes. Portanto, se você usar essa abordagem, armazene o valor original e volte a configurá-lo após cada teste. Para fazer isso facilmente com o Jest, use o método spyOn () em vez de jest.fn()porque ele suporta facilmente a restauração de seu valor original, evitando assim o vazamento mencionado anteriormente.

Você precisa zombar do módulo e definir o espião sozinho:

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

Para simular uma exportação padrão do módulo de dependência ES6 usando o 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);
  });
});

As outras opções não funcionaram no meu caso.

Adicionando mais à resposta de Andreas. Eu tive o mesmo problema com o código ES6, mas não queria alterar as importações. Isso parecia hacky. Então eu fiz isso

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

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

E adicionou dependency.js na pasta "__ zomba __" paralela ao dependency.js. Isso funcionou para mim. Além disso, isso me deu a opção de retornar dados adequados da implementação simulada. Certifique-se de fornecer o caminho correto para o módulo que você deseja zombar.

Avançando rapidamente para 2020, achei este link a solução. usando apenas a sintaxe do módulo 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

Também uma coisa que você precisa saber (o que demorou um pouco para descobrir) é que você não pode chamar jest.mock () dentro do teste; você deve chamá-lo no nível superior do módulo. No entanto, você pode chamar mockImplementation () dentro de testes individuais se desejar configurar simulações diferentes para testes diferentes.

A pergunta já está respondida, mas você pode resolvê-la assim:

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

Eu resolvi isso de outra maneira. Digamos que você tenha seu dependency.js

export const myFunction = () => { }

Eu crio um arquivo depdency.mock.js além dele com o seguinte conteúdo:

export const mockFunction = jest.fn();

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

e no teste, antes de importar o arquivo que possui a impedância que eu uso:

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

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

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})