¿Cómo puedo burlarme de una importación de módulo ES6 usando Jest?

Estoy empezando a pensar que esto no es posible, pero quiero preguntar de todos modos.

Quiero probar que uno de mis módulos ES6 llama a otro módulo ES6 de una manera particular. Con Jasmine esto es súper fácil.

El código de la aplicación:

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

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

Y el código de prueba:

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

¿Cuál es el equivalente con Jest? Siento que esto es algo tan simple que quiero hacer, pero me he estado arrancando el pelo tratando de resolverlo.

Lo más cerca que he estado es reemplazando imports con requires, y moviéndolos dentro de las pruebas / funciones. Ninguna de las cuales son cosas que quiero hacer.

// 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 obtener puntos de bonificación, me encantaría hacer que todo funcione cuando la función dentro dependency.jses una exportación predeterminada. Sin embargo, sé que espiar las exportaciones predeterminadas no funciona en Jasmine (o al menos nunca podría hacerlo funcionar), por lo que tampoco tengo la esperanza de que sea posible en Jest.

He podido resolver esto usando un truco que involucra import *. ¡Incluso funciona para exportaciones con nombre y predeterminadas!

Para una exportación con nombre:

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

O para una exportación predeterminada:

// 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 señaló con razón a continuación, esto está mutando el objeto del módulo dependencyy, por lo tanto, se 'filtrará' a otras pruebas. Entonces, si usa este enfoque, debe almacenar el valor original y luego volverlo a configurar después de cada prueba. Para hacer esto fácilmente con Jest, use el método spyOn () en lugar de jest.fn()porque admite restaurar fácilmente su valor original, evitando así la 'fuga' antes mencionada.

Tienes que burlarte del módulo y configurar el espía tú mismo:

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 burlarse de una exportación predeterminada del módulo de dependencia ES6 usando 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);
  });
});

Las otras opciones no funcionaron para mi caso.

Añadiendo más a la respuesta de Andreas. Tuve el mismo problema con el código ES6 pero no quise mutar las importaciones. Eso parecía hacky. Entonces hice esto

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

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

Y agregó dependency.js en la carpeta "__ mocks __" paralela a dependency.js. Esto funcionó para mí. Además, esto me dio la opción de devolver datos adecuados de la implementación simulada. Asegúrese de dar la ruta correcta al módulo que desea simular.

Avance rápido hasta 2020, este enlace me pareció la solución. utilizando solo la sintaxis del 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

También una cosa que necesita saber (que me llevó un tiempo descubrir) es que no puede llamar a jest.mock () dentro de la prueba; debes llamarlo en el nivel superior del módulo. Sin embargo, puede llamar a mockImplementation () dentro de pruebas individuales si desea configurar diferentes simulacros para diferentes pruebas.

La pregunta ya está respondida, pero puede resolverla así:

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

Resolví esto de otra manera. Digamos que tienes tu dependencia.js

export const myFunction = () => { }

Creo un archivo depdency.mock.js junto con el siguiente contenido:

export const mockFunction = jest.fn();

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

y en la prueba, antes de importar el archivo que tiene la dependencia que uso:

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

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

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})