Come posso prendere in giro un'importazione di un modulo ES6 usando Jest?

Sto iniziando a pensare che questo non sia possibile, ma voglio chiederlo comunque.

Voglio testare che uno dei miei moduli ES6 chiama un altro modulo ES6 in un modo particolare. Con Jasmine è semplicissimo -

Il codice dell'app:

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

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

E il codice di prova:

//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 è l'equivalente con Jest? Sento che questa è una cosa così semplice da voler fare, ma mi sono strappato i capelli cercando di capirlo.

Il più vicino a cui sono arrivato è sostituendo la imports con requires e spostandola all'interno dei test / funzioni. Nessuna delle due cose che voglio fare.

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

Per i punti bonus, mi piacerebbe far funzionare tutto quando la funzione interna dependency.jsè un'esportazione predefinita. Tuttavia, so che lo spionaggio delle esportazioni predefinite non funziona in Jasmine (o almeno non potrei mai farlo funzionare), quindi non sto sperando che sia possibile anche in Jest.

Sono stato in grado di risolverlo utilizzando un hack che coinvolge import *. Funziona anche con esportazioni con nome e predefinite!

Per un'esportazione denominata:

// 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 per un'esportazione predefinita:

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

Come Mihai Damian ha giustamente sottolineato di seguito, questo sta mutando l'oggetto del modulo dependency, e quindi "passerà" ad altri test. Pertanto, se si utilizza questo approccio, è necessario memorizzare il valore originale e quindi ripristinarlo nuovamente dopo ogni test. Per farlo facilmente con Jest, usa il metodo spyOn () invece che jest.fn()perché supporta facilmente il ripristino del suo valore originale, evitando quindi prima di citare "perdite".

Devi prendere in giro il modulo e impostare la spia da solo:

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

Per deridere un'esportazione predefinita del modulo di dipendenza 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);
  });
});

Le altre opzioni non hanno funzionato per il mio caso.

Aggiungendo altro alla risposta di Andreas. Ho avuto lo stesso problema con il codice ES6 ma non volevo mutare le importazioni. Sembrava confuso. Quindi l'ho fatto

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

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

E aggiunto dependency.js nella cartella "__ mock __" parallelamente a dependency.js. Questo ha funzionato per me. Inoltre, questo mi ha dato la possibilità di restituire dati adeguati dall'implementazione fittizia. Assicurati di dare il percorso corretto al modulo che vuoi deridere.

Inoltro rapido al 2020, ho trovato questo link come la soluzione. usando solo la sintassi del modulo 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

Anche una cosa che devi sapere (che mi ha impiegato un po 'di tempo per capire) è che non puoi chiamare jest.mock () all'interno del test; devi chiamarlo al livello superiore del modulo. Tuttavia, è possibile chiamare mockImplementation () all'interno di singoli test se si desidera impostare simulazioni diverse per test diversi.

La domanda ha già una risposta ma puoi risolverla in questo modo:

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

L'ho risolto in un altro modo. Supponiamo che tu abbia il tuo dependency.js

export const myFunction = () => { }

Creo un file depdency.mock.js oltre ad esso con il seguente contenuto:

export const mockFunction = jest.fn();

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

e nel test, prima di importare il file con la dipendenza che uso:

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

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

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})