Jest: How to mock one specific method of a class

javascript

mocking

testing

jest

byAnton Shumikhin·Feb 27, 2025

To mock a single method of your class using Jest, the jest.spyOn() function paired with mockImplementation() or mockReturnValue() will be your best friend. Behold, the magic command isn't hard to invoke:

import MyClass from './MyClass';

// Stare intently at the method to be mocked
const mockMyMethod = jest.spyOn(MyClass.prototype, 'myMethod');

// Whisper the spell of mocking
mockMyMethod.mockReturnValue('mocked value');

Just like that, you've bypassed myMethod, making it return 'mocked value' whenever it's called upon any instance of MyClass, all while every other method sits untouched and clueless.

Break it down, method by method

Mocking only a specific instance method

When mocking an instance method is your game:

let instance = new MyClass();
jest.spyOn(instance, 'myMethod').mockReturnValue('I am uniquely mocked, deal with it');

Be careful, any other MyClass instances will be left as they were, clueless about your covert mocking operation.

Static? We've got that

If static methods are your targets:

jest.spyOn(MyClass, 'staticMyMethod').mockReturnValue('I am statically mocked');

Remember, when it comes to static methods, you don't go after the prototype, you set your sights directly on the class.

Cleaning up the mess

When you're done playing with your toys and want to restore all mocks after an intensive testing session:

afterAll(() => {
  jest.restoreAllMocks();
});

In cases when you need to stop the mocking spell on a sneaky single method and revert it to its innocent original self:

mockMyMethod.mockRestore();

Mock, but keep the others

For those special occasions when you employ jest.mock() but want to keep the rest of the classmates:

jest.mock('./MyClass', () => {
  const originalModule = jest.requireActual('./MyClass');
  return {
    ...originalModule,
    myMethod: jest.fn().mockReturnValue('mocked value'),
  };
});

Handle those arrows

If your method is an arrow function, don't get strung out, just be aware that they're not the best at playing spy games. If possible, convert it into a class method for an easy time testing:

class MyClass {
  myMethod = function() {
    return 'real value';
  }
}

Override? Yes, you can!

You have an option to create a subclass, override the naughty method, and put it into its place:

class MockedClass extends MyClass {
  myMethod() {
    return 'mocked value';
  }
}

Boot up MockedClass in your tests and you're good to go.

TypeScript tricks

In a TypeScript environment, jest.mock() can get a little finicky. Cast it properly:

jest.mock('./MyClass');
const { MyClass } = jest.requireActual('./MyClass');

const mockedMyClass = new MyClass() as jest.Mocked<MyClass>;
mockedMyClass.myMethod.mockReturnValue('mocked value');

Ensure your spy is working

After all, it's not a spy game if we're not sure the bugs are working. Make sure to check the return value or calls:

expect(mockedMyClass.myMethod()).toBe('mocked value');
expect(mockedMyClass.myMethod).toHaveBeenCalledTimes(1);

When things go wrong

Ever caught a mime cursing? It happens! Here's how to untwist any pretzel situations:

Make sure you're mocking an instance method on the prototype, not the instance itself. It's not personal!
Be careful not to mix instance methods and static methods. That's when the balrog appears.
If using jest.requireActual(), use it judiciously and make sure only to mock the guilty method.
In TypeScript, be aware of the casting needed for jest mocks. It's their special way of saying "Nice to meet you".