jest: Mock defined in __mocks__ directory not being used in submodules

I recommend using jest.mock(‘path/to/module/name’, () => {…}) for this. I don’t think we’ll add support for nested manual mock files.

This behavior feels odd to me. Wouldn’t it make sense for __mocks__ to be used all the time in replacement for the actual module, even without the requirement of telling jest to do so? I thought of the mocks in the __mocks__ folder as some kind of global replacement. Limiting the scope of these mocks as discussed here seems broken.

A way to use __mocks__ as a global replacement I stumbled upon is to define such mocks in the jest.setup.js file like so:

jest.mock('../src/some-module', () => jest.requireActual('../src/__mocks__/some-module'));
jest.mock('../src/other-module', () => jest.requireActual('../src/__mocks__/other-module'));

This certainly requires us to re-define each mock in the __mocks__ directory but is a nice combination of being able to define global mocks of a file and defining the actual mock in a dedicated file close to the real module.

@benadamstyles That only works if you’re using the mocked module directly in test. It doesn’t work when the mocked module is a dependency of a different module that is the one under test. In that case, the dependency won’t use its __mocks__ file when called from the module under test.

@cpojer I really like jest, but the documentation around manual mocking seems to be a sore point in a lot of github issues. I’d love to help, but the behaviour is too cryptic. I agree with @MattyKuzyk that it seems counterintuitive that a module under test wouldn’t use a manual mock defined for a dependency when the test explicitly says to jest.mock that module.

Conversely, a manually mocked node_modules dependency IS used when it is called in a module under test, where no jest.mock is needed.

Modules that are mocked with jest.mock are mocked only for the file that calls jest.mock. Another file that imports the module will get the original implementation even if run after the test file that mocks the module.

http://facebook.github.io/jest/docs/en/jest-object.html#jestmockmodulename-factory-options

I found this while searching through the docs. My guess is that is also the official way of thinking with these nested submodules and manual mocking. Maybe this will help clarify for some people, maybe not. Hoping it’s helpful to someone.

I have been having this problem and found this comment, which solved it for me. It should be in the docs.

I found a way to implement the desired behaviour by adding the below to a setup file:

import fs from 'fs';
import path from 'path';

const isDirectory = (dir, file) =>
  fs.statSync(path.join(dir, file)).isDirectory();

const mockExists = (dir, file) =>
  fs.existsSync(path.join(dir, '__mocks__', file));

const mockModule = (dir, file) => {
  jest.doMock(path.join(dir, file), () =>
    jest.requireActual(path.join(dir, '__mocks__', file)));
};

const initMocks = (dir) => {
  fs.readdirSync(dir)
    .forEach((file) => {
      if (isDirectory(dir, file)) {
        initMocks(path.join(dir, file));
      } else if (mockExists(dir, file)) {
        mockModule(dir, file);
      }
    });
};

// This will check all directories below the current directory (__dirname).
initMocks(__dirname);

Is it expected that this works

// in the test
beforeAll(() => {
  saga2.foo = function * () {
    yield 'something'
    return 'fake foo'
  }
}

and this doesn’t?

// in the test
jest.mock('./saga2', () => jest.requireActual('./__mocks__/saga2.js'))

// in `./__mocks__/saga2.js`
export function * foo () {
  yield 'something'
  return 'fake foo'
}

I thought they should be equivalent from the mocking perspective.

I’d love to be able to reuse mocks without having to write them in every test that needs the mocked code, but there doesn’t seem to be an easy way of doing so. It’s possible that I’m missing something here.

For the ones researching, the way I solved my problem: (Want to define only 1 mock, to be used in all my tests) was to import all my mocks into setupTests.ts file.

// Content of setupTests.js
import "@testing-library/jest-dom/extend-expect";
import "./tests/mocks/aws-sdk";

// Content of /tetsts/mock/aws-sdk.ts
import "@testing-library/jest-dom/extend-expect";

jest.mock("aws-sdk", () => ({
  CognitoIdentityCredentials: jest.fn(),
  config: {},
  S3: jest.fn().mockImplementation(() => ({
    foo: "bar",
    listObjectsV2: (options: any, callback: any) =>
      callback(null, { Contents: [] }),
  })),
}));

This allowed me to centralize the definition of my mocks for all my testing for easier maintenance. I agree with previous commenters that the __mocks__ behavior is poorly defined in the documentation. It took me many hours of trial and errors and mind-boggling confusion to get to a working solution

We aren’t currently investing in improvements to the mock system heavily. If you’d like to work on this please join us on discord (#jest on reactiflux) and I’m happy to help you get a PR ready 😃