Как я могу издеваться над импортом модуля ES6 с помощью Jest?

Я начинаю думать, что это невозможно, но я все равно хочу спросить.

Я хочу проверить, что один из моих модулей ES6 вызывает другой модуль ES6 определенным образом. С Жасмином это очень просто -

Код приложения:

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

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

И тестовый код:

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

Что эквивалентно с Джестом? Я чувствую, что это такая простая вещь, которую я хочу сделать, но я рвал на себе волосы, пытаясь понять это.

Самое близкое, что я получил, - это заменить imports на requires и поместить их в тесты / функции. Ничего из того, что я хочу делать.

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

Что касается бонусных баллов, я бы хотел, чтобы все это работало, когда функция внутри dependency.js- экспорт по умолчанию. Тем не менее, я знаю, что слежка за экспортом по умолчанию не работает в Jasmine (или, по крайней мере, я никогда не смогу заставить его работать), поэтому я не надеюсь, что это возможно в Jest.

Я смог решить эту проблему с помощью взлома с участием import *. Это даже работает как для именованных, так и для экспорта по умолчанию!

Для именованного экспорта:

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

Или для экспорта по умолчанию:

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

Как справедливо заметил Михай Дамиан ниже, это мутирует объект модуля dependency, и поэтому он «просочится» в другие тесты. Поэтому, если вы используете этот подход, вы должны сохранить исходное значение и затем устанавливать его снова после каждого теста. Чтобы сделать это легко с помощью Jest, используйте метод spyOn () вместо того, jest.fn()потому что он поддерживает простое восстановление исходного значения, поэтому избегая ранее упомянутого «утечки».

Вы должны смоделировать модуль и установить шпиона самостоятельно:

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

Чтобы смоделировать экспорт модуля зависимостей ES6 по умолчанию с помощью 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);
  });
});

Другие варианты не работали для моего случая.

Добавляю ещё Андреасу ответ. У меня была та же проблема с кодом ES6, но я не хотел изменять импорт. Это выглядело хакерским. Так я и сделал

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

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

И добавил зависимости.js в папку «__ mocks __» параллельно с зависимостью.js. Это сработало для меня. Кроме того, это дало мне возможность вернуть подходящие данные из фиктивной реализации. Убедитесь, что вы указали правильный путь к модулю, который хотите смоделировать.

Перейдя к 2020 году, я нашел эту ссылку решением проблемы. используя только синтаксис модуля 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

Также одна вещь, которую вам нужно знать (на что у меня ушло некоторое время, чтобы понять), что вы не можете вызвать jest.mock () внутри теста; Вы должны вызвать его на верхнем уровне модуля. Однако вы можете вызывать mockImplementation () внутри отдельных тестов, если вы хотите настроить разные макеты для разных тестов.

На вопрос уже дан ответ, но вы можете решить его следующим образом:

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

Я решил это по-другому. Допустим, у вас есть ваш dependency.js

export const myFunction = () => { }

Помимо этого, я создаю файл depdency.mock.js со следующим содержимым:

export const mockFunction = jest.fn();

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

и в тесте, прежде чем импортировать файл с зависимостью, которую я использую:

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

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

    functionThatCallsDep();

    expect(mockFunction).toHaveBeenCalled();

})