Can I mock functions with specific arguments using Jest?

Question

I want to mock a function with Jest, but only if it is called with specific arguments, for example:

function sum(x, y) {
  return x + y;
}
    
// mock sum(1, 1) to return 4
sum(1, 1) // returns 4 (mocked)
sum(1, 2) // returns 3 (not mocked)

There is a similar feature implemented in Ruby's RSpec library:

class Math
  def self.sum(x, y)
    return x + y
  end
end

allow(Math).to receive(:sum).with(1, 1).and_return(4)
Math.sum(1, 1) # returns 4 (mocked)
Math.sum(1, 2) # returns 3 (not mocked)

What I'm trying to achieve in my tests is a better decoupling, let's say I want to test a function that relies on sum:

function sum2(x) {
  return sum(x, 2);
}

// I don't want to depend on the sum implementation in my tests, 
// so I would like to mock sum(1, 2) to be "anything I want", 
// and so be able to test:

expect(sum2(1)).toBe("anything I want");

// If this test passes, I've the guarantee that sum2(x) is returning
// sum(x, 2), but I don't have to know what sum(x, 2) should return

I know that there is a way to implement this by doing something like:

sum = jest.fn(function (x, y) {
  if (x === 1 && y === 2) {
    return "anything I want";
  } else {
    return sum(x, y);
  }
});

expect(sum2(1)).toBe("anything I want");

But it would be nice if we had some sugar function to simplify it.

Does it sounds reasonable? Do we already have this feature in Jest?

Thanks for your feedback.

I've been dealing with this too, but in the end figured a very simple solution: const functionResult = myFunc(args); expect(functionResult).toBe('whatever'); — paddotk
– paddotk, Commented Aug 26, 2021 at 16:08

STeve Shary · Accepted Answer · 2018-03-14 15:19:49Z

130

I found this library that a colleague of mine wrote recently: jest-when

import { when } from 'jest-when';

const fn = jest.fn();
when(fn).calledWith(1).mockReturnValue('yay!');

const result = fn(1);
expect(result).toEqual('yay!');

Here's the library: https://github.com/timkindberg/jest-when

answered Mar 14, 2018 at 15:19

STeve Shary

1,5151 gold badge9 silver badges9 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

awvalenti · Accepted Answer · 2020-04-09 21:31:19Z

85

jest-when mentioned by STeve Shary is probably the best option.

If you don't want to install a new library, when you don't care about the original function, here's a one-line solution:

sum.mockImplementation((x, y) => x === 1 && y === 2 && "my-return-value")

answered Apr 9, 2020 at 21:31

awvalenti

2,05120 silver badges22 bronze badges

7 Comments

theberzi Over a year ago

Thanks for providing an alternative that doesn't require an external library.

theberzi Over a year ago

If the order of the calls is known, it might be easier to instead chain .mockReturnValueOnce() multiple times.

awvalenti Over a year ago

But then you won't be able to set expectations on arguments

theberzi Over a year ago

This is mocking. It's assumed that the thing being mocked is not under test, otherwise it shouldn't be mocked at all.

awvalenti Over a year ago

It is part of the test to ensure that correct arguments are passed

|

peanutz · Accepted Answer · 2022-06-27 20:28:13Z

27

import * as helper from "../helper";  //file where all functions are

jest.spyOn(helper, "function_name").mockImplementation((argument) => {

// This argument is the one passed to the function you are mocking

  if (argument === "something") {
    return "something"
  } else {
    return "something else"
  }
});

edited Jun 27, 2022 at 20:28

answered Jun 27, 2022 at 20:17

peanutz

5568 silver badges8 bronze badges

Comments

Luke Garrigan · Accepted Answer · 2021-04-09 15:26:34Z

18

I thought I needed a way to mock with arguments too, but for me, I could solve my problem by simply knowing the order of calls.

Taken from the jest documentation

const filterTestFn = jest.fn();

// Make the mock return `true` for the first call,
// and `false` for the second call
filterTestFn.mockReturnValueOnce(true).mockReturnValueOnce(false);

So in the example above, provided you know that on first pass the function should return true and on second pass it should return false, you're good to go!

answered Apr 9, 2021 at 15:26

Luke Garrigan

5,0811 gold badge26 silver badges32 bronze badges

6 Comments

Hanchen Jiang Over a year ago

I think this kind of tests are fragile because it depends on a very specific implementation. If the order of the calls aren't important in the implementation, I would not suggest with this approach.

Luke Garrigan Over a year ago

No, but this solution is for the scenario where the order of calls are important.

Hanchen Jiang Over a year ago

OK. I just don't think the order of calls are important for OP's case so I wouldn't suggest this solution to OP.

Luke Garrigan Over a year ago

Not to the specific question no, but if you google "Can I mock functions with specific arguments using Jest" this question comes up and my answer is just merely pointing out that you may not need what you think you need.

Hanchen Jiang Over a year ago

Yeah that's fair.

|

Community · Accepted Answer · 2020-06-20 09:12:55Z

13

No there is no way to do this in Jest yet. You could use sinons stubs for this. from the docs:

stub.withArgs(arg1[, arg2, ...]);

Stubs the method only for the provided arguments. This is useful to be more expressive in your assertions, where you can access the spy with the same call. It is also useful to create a stub that can act differently in response to different arguments.

"test should stub method differently based on arguments": function () {
    var callback = sinon.stub();
    callback.withArgs(42).returns(1);
    callback.withArgs(1).throws("TypeError");

    callback(); // No return value, no exception
    callback(42); // Returns 1
    callback(1); // Throws TypeError
}

edited Jun 20, 2020 at 9:12

CommunityBot

11 silver badge

answered Jan 17, 2017 at 13:03

Andreas Köberle

112k58 gold badges281 silver badges308 bronze badges

Comments

Adam · Accepted Answer · 2017-04-20 14:24:11Z

2

This may help...

I had something similar whereby I had the same method called with different parameters requiring different returned result from the stubbed/mocked call. I've used a variable with a list of functions when I've made a call to the mocked service i take function off the top of the queue and execute function. It requires knowledge of the order of execution you are testing and doesn't really handle varying the response by argument but has allowed me to work around the restriction in jest.

var mockedQueue = [];
mockedQueue.push(() => {return 'A';})
mockedQueue.push(() => {return 'B';})

service.invoke = jest.fn(()=>{
    serviceFunctionToCall = mockedQueue.shift();
    return serviceFunctionToCall();
})

answered Apr 20, 2017 at 14:24

Adam

4421 gold badge5 silver badges17 bronze badges

1 Comment

Black Over a year ago

You can just use mockReturnValueOnce multiple times instead of this

Dan Murphy - Boulder · Accepted Answer · 2024-08-26 19:17:17Z

1

You can do this in Jest, no external library required. Just keep a reference to the original implementation:

import * as MyModule from "./MyModule";

const originalMyFunction = MyModule.myFunction;

jest.spyOn(MyModule, "myFunction").mockImplementation((key) => {
 if (key === "keyIWantToMock") {
   return "someMockedValue";
 } else {
   return originalMyFunction(key);
 }
});

edited Aug 26, 2024 at 19:17

answered Aug 26, 2024 at 16:32

Dan Murphy - Boulder

3014 silver badges6 bronze badges

4 Comments

Yorkshireman Over a year ago

I've been trying this but I get RangeError: Maximum call stack size exceeded errors

Dan Murphy - Boulder Over a year ago

Can you share your code @Yorkshireman?

Yorkshireman Over a year ago

Sorry Dan - I can't remember where the code was that I was working on with this - was a few weeks ago and it's been lost to the dusty drawers of my memory!

Dan Murphy - Boulder Over a year ago

No worries :) my hunch is that if you were seeing maximum call stack size exceeded errors you were probably directly calling MyModule.myFunction inside the callback of mockImplementation, rather than calling a reference to the original value of MyModule.myFunction (originalMyFunction in my example)

Collectives™ on Stack Overflow

Can I mock functions with specific arguments using Jest?

7 Answers 7

Comments

7 Comments

Comments

6 Comments

Comments

1 Comment

4 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

Comments

7 Comments

Comments

6 Comments

Comments

1 Comment

4 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related