jest.spyOn 相当于 jest.mock

Question

Mock a whole module but retain original module logic. Similar to jest.spyOn default behaviour, where the original method is called.

Using jest.mock allows performing the assertions needed, but doesn't execute the original logic and sometimes I want that logic to be executed. Using jest.spyOn allows assertion and can execute original logic, but only on named exports of the module, which is generally useful but not when the method is exported as default or like in the sample code below.

// moduleToMock.js
function doSomething(..args) {...}

doSomething.myWay = function myWay(...args) {...}

module.exports = doSomething

// moduleUsingModuleToMock.js
const doSomething = require('moduleToMock')

function doManyThings() {
    doSomething(...)
    doSomething.myWay(...)
}

module.exports = {
    doManyThings,
}

// moduleUsingModuleToMock.test.js
// --
// some way to mock `moduleToMock` that still executes original logic
// --
const doSomething = require('moduleUsingModuleToMock')
it('correctly does many things', () => {
    doManyThings()
    expect(doSomething).toBeCalledWith(...)
    expect(doSomething.myWay).toBeCalledWith(...)
})

Maybe I missed something simple, but so far docs or google fu hasn't yielded any results.

Answer 1

There is no way to mock a module and spy on its methods. The reason is that jest really replace the module with the mock.

Answer 2

I'm currently doing it like this

jest.mock('./somepath', () => (
  Object.fromEntries(
    Object.entries(jest.requireActual('./somepath'))
      .map(([key, value]) => [key, jest.fn(value)])
  )
))

this makes the module retain the original implementation but since all the exports are wrapped in jest.fn they can now be mocked with a different implementation in each particular test

Answer 3

This came up often enough that I just decided to write my own library for generating auto mocks of modules that keep the original implementation but can be overridden just like jest.spyOn .

Jest Mock Module

import * as mock from "jest-mock-module";
mock.extend(jest); // optionally extend jest to use the "jest.spy" syntax
jest.spy("src/moduleToMock"); // Placed before other imports like "jest.mock".

import moduleToMock from "src/moduleToMock";
import moduleToTest from "src/moduleToTest";

it("does a thing", () => {
  moduleToTest.callFunctionThatUsesModuleToMock();
  expect(moduleToMock.usedFunction).toHaveBeenCalledTimes(1);
});