Jak mogę wyśmiewać import modułu ES6 za pomocą Jest?

Zaczynam myśleć, że to nie jest możliwe, ale i tak chcę zapytać.

Chcę przetestować, czy jeden z moich modułów ES6 wywołuje inny moduł ES6 w określony sposób. Z Jasmine jest to bardzo łatwe -

Kod aplikacji:

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

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

I kod testowy:

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

Jaki jest odpowiednik Jest? Wydaje mi się, że jest to bardzo prosta rzecz, ale chcę oderwać włosy, próbując to rozgryźć.

Najbliższe, jakie przyszedłem, to zamiana imports na requires i przenoszenie ich wewnątrz testów / funkcji. Żadnej z tych rzeczy nie chcę robić.

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

Jeśli chodzi o punkty bonusowe, chciałbym, aby wszystko działało, gdy funkcja wewnątrz dependency.jsjest domyślnym eksportem. Wiem jednak, że szpiegowanie domyślnych eksportów nie działa w Jasmine (a przynajmniej nigdy nie udało mi się go uruchomić), więc nie mam nadziei, że jest to możliwe w Jest.

Udało mi się to rozwiązać za pomocą włamania import *. Działa nawet w przypadku nazwanych i domyślnych eksportów!

W przypadku nazwanego eksportu:

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

Lub w przypadku domyślnego eksportu:

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

Jak słusznie wskazał Mihai Damian poniżej, powoduje to mutację obiektu modułu dependency, a więc „przecieka” do innych testów. Jeśli więc zastosujesz to podejście, powinieneś zapisać oryginalną wartość, a następnie ustawić ją ponownie po każdym teście. Aby to zrobić z pomocą Jest, użyj metody spyOn () zamiast, jest.fn()ponieważ obsługuje łatwe przywracanie pierwotnej wartości, dzięki czemu unika się wcześniej wspomnianego „wycieku”.

Musisz wyśmiewać moduł i sam ustawić szpiega:

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

Aby wyśmiewać domyślny eksport modułu zależności ES6 za pomocą 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);
  });
});

Inne opcje nie działały w moim przypadku.

Dodając więcej do odpowiedzi Andreasa. Miałem ten sam problem z kodem ES6, ale nie chciałem mutować importu. To wyglądało okropnie. Więc to zrobiłem

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

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

I dodano plik dependence.js w folderze „__ mocks __” równolegle do pliku dependency.js. To zadziałało dla mnie. Dało mi to również możliwość zwrócenia odpowiednich danych z fałszywej implementacji. Upewnij się, że podałeś prawidłową ścieżkę do modułu, z którego chcesz się wyśmiewać.

Szybkie przejście do 2020 roku, znalazłem ten link jako rozwiązanie. za pomocą tylko składni modułu 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

Jedną rzeczą, którą musisz wiedzieć (co zajęło mi trochę czasu, aby to rozgryźć) jest to, że nie możesz wywołać jest.mock () w teście; musisz to nazwać na najwyższym poziomie modułu. Możesz jednak wywołać mockImplementation () w ramach poszczególnych testów, jeśli chcesz skonfigurować różne próby dla różnych testów.

Odpowiedź na pytanie jest już udzielona, ​​ale możesz rozwiązać go w następujący sposób:

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

Rozwiązałem to w inny sposób. Załóżmy, że masz plik dependence.js

export const myFunction = () => { }

Oprócz tego tworzę plik depdency.mock.js z następującą zawartością:

export const mockFunction = jest.fn();

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

i w teście, zanim zaimportuję plik, którego używam zależności, używam:

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

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

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})