Closed seibelj closed 8 years ago
@nickofthyme, Option 1 is correct as you have it. But if you change the code to:
const foo = () => {}
export { foo }
Then it breaks. Presumably because you create a new object literal and export that.
Interesting observation. Thanks @maletor
Jest has a very simple and clear example in their documentation of how to partially mock a module. This works with both ES import and Node require statements. https://jestjs.io/docs/en/jest-object#jestrequireactualmodulename
@johncmunson That's a good point. However, this example you showed of mocking a module only works if you only need to run jest.mock
once and none of the mocked method use another export from that module.
Take the example from above...I've added bar
to show how I want to mock the module differently between foo
and bar
.
export const message = (): string => {
return 'Hello world';
}
export const foo = (): string => {
return message();
}
export const bar = (): (() => string) => {
return foo;
}
Using jest.mock
with jest.requireActual
I think would go something like this.
import * as mockTestModule from './hello';
jest.mock('./hello');
const actualTestModule = jest.requireActual('./hello');
describe('test hello', function () {
afterAll(() => {
jest.restoreAllMocks();
});
// first test doesn't depend on any other method of the module so no mocks
it('should NOT mock message in foo', function () {
const actual = actualTestModule.foo();
expect(actual).toBe('Hello world');
});
// the second I want to mock message in foo
it('should mock message in foo', function () {
jest.spyOn(mockTestModule, 'message').mockReturnValue('my message');
const actual = actualTestModule.foo();
expect(actual).toBe('my message'); // fails
expect(mockTestModule.message).toHaveBeenCalledTimes(1); // never called
});
it('should mock foo in bar', function () {
jest.spyOn(mockTestModule, 'foo').mockReturnValue('my message');
const actual = actualTestModule.bar();
expect(actual()).toBe('my message'); // fails
expect(mockTestModule.message).toHaveBeenCalledTimes(1); // never called
});
});
I even tried mocking them separately with jest.doMock
and still got the same result.
The issue with this approach is that requiring the actual module, then say calling foo
, still calls the actual message
function and not the mock.
I wish it were this simple but from what I see this does not help for the examples from this thread. If I am missing something here please let me know. I'll gladly admit fault.
For anyone who comes across this looking for a solution, the following seems to be working for me when exporting many const/functions in one file, and importing them in a file which I'm testing
function mockFunctions() { const original = require.requireActual('../myModule'); return { ...original, //Pass down all the exported objects test: jest.fn(() => {console.log('I didnt call the original')}), someFnIWantToCurry: {console.log('I will curry the original') return jest.fn((...args) => original.someFnIWantToCurry(...args)}), } jest.mock('../myModule', () => mockFunctions()); const storage = require.requireMock('../myModule'); `
The following works and is a bit shorter:
const module = require('./module');
jest.spyOn(module, 'myFn').mockImplementation(() => 'val');
In Typescript, just import
instead of require
:
import * as module from './module';
This has the advantage of making life easy to restore original functions and clear mocks.
For anyone who comes across this looking for a solution, the following seems to be working for me when exporting many const/functions in one file, and importing them in a file which I'm testing
function mockFunctions() { const original = require.requireActual('../myModule'); return { ...original, //Pass down all the exported objects test: jest.fn(() => {console.log('I didnt call the original')}), someFnIWantToCurry: {console.log('I will curry the original') return jest.fn((...args) => original.someFnIWantToCurry(...args)}), } jest.mock('../myModule', () => mockFunctions()); const storage = require.requireMock('../myModule'); `
The following works and is a bit shorter:
const module = require('./module'); jest.spyOn(module, 'myFn').mockImplementation(() => 'val');
In Typescript, just
import
instead ofrequire
:import * as module from './module';
This has the advantage of making life easy to restore original functions and clear mocks.
Oh, yes also this method is not working if your object only has getter
defined. The error message could be like below:
Test suite failed to run
TypeError: Cannot set property useContent of #<Object> which has only a getter
Probably need to use jest.mock(..)
for this case. :bowing_man:
My mocks are working by using the following:
import { unsubscribe } from "../lib/my-lib"
import { MyComponent } from "./index"
test("unsubscribe gets called", () => {
const module = require("../lib/my-lib")
jest.spyOn(
module,
"unsubscribe"
).mockImplementation(() => jest.fn())
const { getByTestId } = render(() => <MyComponent />)
let button = getByTestId("trigger.some.action.button")
fireEvent.press(button)
expect(unsubscribe).toHaveBeenCalled()
})
It doesn't seem so elegant and doesn't scale so easily, it works very well though and suits my cases for now.. but if anybody can suggest any other syntax that would be great! This is the only syntax that seems to be working.
es6 module code:
export const funcA = () => {};
export const funcB = () => {
funcA();
};
After transpiled to CommonJS:
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.funcB = exports.funcA = void 0;
var funcA = function funcA() {};
exports.funcA = funcA; // You can mock or add a spy on this `funcA`
var funcB = function funcB() {
funcA(); // This is still original `funcA`
};
exports.funcB = funcB;
There are many ways to solve this situation.
funcA
function funcA() {}
exports.funcA = funcA;
function funcB() {
exports.funcA(); // Now, this exports.funcA
is added a spy or mocked. Keep the same reference to funcA
}
exports.funcB = funcB;
Or,
```js
export let funcA = () => {};
export const funcB = () => {
exports.funcA();
};
unit test results:
PASS myModule.test.ts (9.225s)
funcB
✓ should call funcA (3ms)
-------------|---------|----------|---------|---------|-------------------
File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
-------------|---------|----------|---------|---------|-------------------
All files | 100 | 100 | 100 | 100 |
myModule.ts | 100 | 100 | 100 | 100 |
-------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 10.967s
funcA
...Besides, you need to take a look at this docs: https://nodejs.org/api/modules.html#modules_exports_shortcut, to see what exactly does require
do
The solution in this stackoverflow post worked for me https://stackoverflow.com/a/53402206/1217998
Basically first you convert all the functions you want to convert to jest.fn
jest.mock('../../utils', () => {
const actualUtils = jest.requireActual('../../utils');
const originalImplementation = actualUtils.someFun;
return {
...actualUtils,
someFun: jest.fn()
.mockImplementation(originalImplementation),
};
});
const utils = require('../../utils');
Then you can use it like normal if you want or mock it like this
jest.spyOn(utils, 'someFun').mockReturnValueOnce(true);
You can use this to get the original implementation
beforeEach(() => {
jest.clearAllMocks();
});
The solution in this stackoverflow post worked for me https://stackoverflow.com/a/53402206/1217998
Basically first you convert all the functions you want to convert to
jest.fn
jest.mock('../../utils', () => { const actualUtils = jest.requireActual('../../utils'); const originalImplementation = actualUtils.someFun; return { ...actualUtils, someFun: jest.fn() .mockImplementation(originalImplementation), }; }); const utils = require('../../utils');
Then you can use it like normal if you want or mock it like this
jest.spyOn(utils, 'someFun').mockReturnValueOnce(true);
You can use this to get the original implementation
beforeEach(() => { jest.clearAllMocks(); });
Thank you!
Jest has a very simple and clear example in their documentation of how to partially mock a module. This works with both ES import and Node require statements. https://jestjs.io/docs/en/jest-object#jestrequireactualmodulename
Does not work when the mocked function is called from within the module.
Also, I found that sometimes it can be useful to mock function the way that you don't change the original function but call function with some custom (additional) variables:
jest.mock('./someModule', () => {
const moduleMock = require.requireActual('./someModule');
return {
...moduleMock,
// will mock this function
someFunction: (args) =>
moduleMock.someFunction({
...args,
customArgument,
}),
};
});
In my case I needed to pass come config to function without which it would use default one.
This is the only way I found to do this, so if you come up with some better or easier ideas, will be glad to hear :)
FWIW I've pulled together various approaches with runnable examples in https://github.com/magicmark/jest-how-do-i-mock-x/blob/master/src/function-in-same-module/README.md
This does not answer the OPs question/issue, but is a solution with some refactoring involved. I've found separating my functions into different files, and then mocking those imports, is the easiest thing to do.
// package.json
...
"scripts": {
"test": "jest",
...
"devDependencies": {
"@babel/preset-env": "^7.11.5",
"jest": "^24.9.0",
...
// babel.config.js
module.exports = {
presets: [
[
'@babel/preset-env',
{
targets: {
node: 'current',
},
},
],
],
};
// module-utils.js
export const isBabaYaga = () => {
return false
}
// module.js
import { isBabaYaga } from './module-utils'
export const isJohnWickBabaYaga = () => {
return isBabaYaga()
}
// modules.test.js
import { isJohnWickBabaYaga } from './module';
jest.mock('./module-utils', () => ({
isBabaYaga: jest.fn(() => true)
}))
test('John Wick is the Baba Yaga', () => {
// when
const isBabaYaga = isJohnWickBabaYaga()
// then
expect(isBabaYaga).toBeTruthy()
});
PASS src/module.test.js
✓ John Wick is the Baba Yaga (4ms)
I've recently run into this issue. None of the proposed solutions work for me because I'm unable to change the code. The babel-plugin-rewire also does not work for me. Is there any other solutions out there to test that a function was called by another function within the same module? This honestly seems like it should work or that there should be a babel plugin out there that does this. Any help would be much appreciated!
I've recently run into this issue. None of the proposed solutions work for me because I'm unable to change the code. The babel-plugin-rewire also does not work for me. Is there any other solutions out there to test that a function was called by another function within the same module? This honestly seems like it should work or that there should be a babel plugin out there that does this. Any help would be much appreciated!
Have you checked out https://github.com/facebook/jest/issues/936#issuecomment-659597840? There's a minimal repro in there that mocks functions calls in the same file.
Reading this thread I was unable to find any working solution for TypeScript. This is how I've managed to solve the issue. Moreover, using jest.doMock() it's possible to mock module functions only in some specific tests of a test file and provide an individual mock implementations for each of them.
src/module.ts
import * as module from './module';
function foo(): string {
return `foo${module.bar()}`;
}
function bar(): string {
return 'bar';
}
export { foo, bar };
test/module.test.ts
import { mockModulePartially } from './helpers';
import * as module from '../src/module';
const { foo } = module;
describe('test suite', () => {
beforeEach(function() {
jest.resetModules();
});
it('do not mock bar 1', async() => {
expect(foo()).toEqual('foobar');
});
it('mock bar', async() => {
mockModulePartially('../src/module', () => ({
bar: jest.fn().mockImplementation(() => 'BAR')
}));
const module = await import('../src/module');
const { foo } = module;
expect(foo()).toEqual('fooBAR');
});
it('do not mock bar 2', async() => {
expect(foo()).toEqual('foobar');
});
});
test/helpers.ts
export function mockModulePartially(
modulePath: string,
mocksCreator: (originalModule: any) => Record<string, any>
): void {
const testRelativePath = path.relative(path.dirname(expect.getState().testPath), __dirname);
const fixedModulePath = path.relative(testRelativePath, modulePath);
jest.doMock(fixedModulePath, () => {
const originalModule = jest.requireActual(fixedModulePath);
return { ...originalModule, ...mocksCreator(originalModule) };
});
}
Mocking functions of a module is moved to helper function mockModulePartially
located in a separate file so it can be used from different test files (which, in common, can be located in other directories). It relies on expect.getState().testPath
to fix path to a module (modulePath
) being mocked (make it relative to helpers.ts
containing mockModulePartially
). mocksCreator
function passed as a second argument to mockModulePartially
should return mocks of the module. This function receives originalModule
and mock implementations can optionally rely on it.
Reading this thread I was unable to find any working solution for TypeScript. This is how I've managed to solve the issue. Moreover, using jest.doMock() it's possible to mock module functions only in some specific tests of a test file and provide an individual mock implementations for each of them.
src/module.ts
import * as module from './module'; function foo(): string { return `foo${module.bar()}`; } function bar(): string { return 'bar'; } export { foo, bar };
test/module.test.ts
import { mockModulePartially } from './helpers'; import * as module from '../src/module'; const { foo } = module; describe('test suite', () => { beforeEach(function() { jest.resetModules(); }); it('do not mock bar 1', async() => { expect(foo()).toEqual('foobar'); }); it('mock bar', async() => { mockModulePartially('../src/module', () => ({ bar: jest.fn().mockImplementation(() => 'BAR') })); const module = await import('../src/module'); const { foo } = module; expect(foo()).toEqual('fooBAR'); }); it('do not mock bar 2', async() => { expect(foo()).toEqual('foobar'); }); });
test/helpers.ts
export function mockModulePartially( modulePath: string, mocksCreator: (originalModule: any) => Record<string, any> ): void { const testRelativePath = path.relative(path.dirname(expect.getState().testPath), __dirname); const fixedModulePath = path.relative(testRelativePath, modulePath); jest.doMock(fixedModulePath, () => { const originalModule = jest.requireActual(fixedModulePath); return { ...originalModule, ...mocksCreator(originalModule) }; }); }
Mocking functions of a module is moved to helper function
mockModulePartially
located in a separate file so it can be used from different test files (which, in common, can be located in other directories). It relies onexpect.getState().testPath
to fix path to a module (modulePath
) being mocked (make it relative tohelpers.ts
containingmockModulePartially
).mocksCreator
function passed as a second argument tomockModulePartially
should return mocks of the module. This function receivesoriginalModule
and mock implementations can optionally rely on it.
@ezze Option 1 from @nickofthyme comment worked in TS for me. Then you don't need any helpers.
@ezze Option 1 from @nickofthyme comment worked in TS for me. Then you don't need any helpers.
@gerkenv Thanks for pointing it out but it requires to replace all function declarations by function expressions that sometimes is not a good option for already existing big projects.
For anyone who comes across this looking for a solution, the following seems to be working for me when exporting many const/functions in one file, and importing them in a file which I'm testing
function mockFunctions() { const original = require.requireActual('../myModule'); return { ...original, //Pass down all the exported objects test: jest.fn(() => {console.log('I didnt call the original')}), someFnIWantToCurry: {console.log('I will curry the original') return jest.fn((...args) => original.someFnIWantToCurry(...args)}), } jest.mock('../myModule', () => mockFunctions()); const storage = require.requireMock('../myModule'); `
i'm come form 2021 🤣,nowadays this is more general in typescript and ES2015+.
i think jest Integrate this in a new api / override or other way would be better,waiting for ECMA improve this and update unify,not user implement it in every project.
this solution still buggy , if mock module have inner reference it's can't be mocked
Five years late to the party, but if you're using Babel (i.e. @babel/parser
) to handle transpiling your TS/ES6+/JS, as I am in this TypeScript project, I wrote babel-plugin-explicit-exports-references
, a plugin that pretty elegantly solves this problem across my repos. It may solve it for you too.
I use it in my Jest tests along with spying to intuitively mock only specific module functions without rewriting my source, using TypeScript-incompatible dark magic like rewire
, or tinkering with hacky nth-level-monkey-patched Jest mocks, beautiful as they are 🙂.
The plugin replaces all internal references to each module's own exported items with an explicit reference to those items in the form of a module.exports.X
member expression. tl;dr it does what @cpojer described above, but automatically.
Before:
// file: myModule.ts
export function foo() {
// expensive network calls
}
export function bar() {
// ...
foo();
}
export function baz() {
// ...
foo();
}
After babel-plugin-explicit-exports-references:
// file: myModule.ts
export function foo() {
// expensive network calls
}
export function bar() {
// ...
module.exports.foo();
}
export function baz() {
// ...
module.exports.foo();
}
And finally, after @babel/preset-env
and @babel/preset-typescript
and everything else runs, the final result looks like:
// file: myModule.js
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.foo = foo;
exports.bar = bar;
exports.baz = baz;
function foo() {// expensive network calls
}
function bar() {
// ...
module.exports.foo();
}
function baz() {
// ...
module.exports.foo();
}
And that's it 🚀 For usage examples, see babel.config.js
loading the plugin only when NODE_ENV=test
, install-deps.ts
exporting multiple functions that reference each other internally, and unit-utils.test.ts
using Jest spies to test each function in isolation (without the plugin, the mock/spy at this line does not work).
I use the plugin only when running Jest tests (so: not in production), since it adds needless characters to the bundle.
If you're coming to this thread to understand how to mock a function called by the function you're testing within the same module, this comment is exactly what you're looking for: https://github.com/facebook/jest/issues/936#issuecomment-545080082
This issue has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs. Please note this issue tracker is not a help forum. We recommend using StackOverflow or our discord channel for questions.
I'm struggling with something that I think should be both easy and obvious, but for whatever reason I can't figure it out.
I have a module. It exports multiple functions. Here is
myModule.js
:I unmock the module for testing.
jest.unmock('./myModule.js');
However, I need to mock
foo
, because it makes ajax calls to my backend. I want every function in this file to remain unmocked, expect forfoo
, which I want to be mocked. And the functionsbar
andbaz
make calls internally tofoo
, so when my test callsbar()
, the unmockedbar
will call the mockedfoo
.It appears in the jest documentation that calls to
unmock
andmock
operate on the entire module. How can I mock a specific function? Arbitrarily breaking up my code into separate modules so they can be tested properly is ridiculous.