How do you change the behaviour of a mocked import in Jest?
Asked Answered
C

8

132

I am having trouble changing the behaviour of a mocked module in Jest. I want to mock different behaviours to test how my code will act under those differing circumstances. I don't know how to do this because calls to jest.mock() are hoisted to the top of the file, so I can't just call jest.mock() for each test. Is there a way to change the behaviour of a mocked module for one test?

jest.mock('the-package-to-mock', () => ({
    methodToMock: jest.fn(() => console.log('Hello'))
}))

import * as theThingToTest from './toTest'
import * as types from './types'

it('Test A', () => {
    expect(theThingToTest.someAction().type).toBe(types.SOME_TYPE)
})

it('Test B', () => {
    // I need the-package-to-mock.methodToMock to behave differently here
    expect(theThingToTest.someAction().type).toBe(types.OTHER_TYPE)
})

Internally, as you can imagine, theThingToTest.someAction() imports and uses the-package-to-mock.methodToMock().

Consentaneous answered 10/7, 2017 at 7:38 Comment(2)
Does this answer your question? How to change mock implementation on a per single test basis [Jestjs]Rocketeer
This is the best answer that I found https://mcmap.net/q/116360/-how-to-change-mock-implementation-on-a-per-single-test-basisSharice
P
233

After you've mocked the module and replaced the methodToMock with a spy, you need to import it. Then, at each test, you can change the behaviour of methodToMock by calling the mockImplementation spy method.

jest.mock('the-package-to-mock', () => ({
    methodToMock: jest.fn()
}))

import { methodToMock } from 'the-package-to-mock'

it('Test A', () => {
    methodToMock.mockImplementation(() => 'Value A')
    // Test your function that uses the mocked package's function here.
})

it('Test B', () => {
    methodToMock.mockImplementation(() => 'Value B')
    // Test the code again, but now your function will get a different value when it calls the mocked package's function.
})
Piero answered 10/7, 2017 at 9:0 Comment(12)
thanks a lot for the answer, it works like a charm :)Consentaneous
What if methodToMock is a constant property instead?Reginareginald
Why would you need to mock a constant value. Anyway, just replace jest.fn() with the value. Also no need to import the module then.Bastion
I get mockImplementation() is not a function when I attempt this method.Forespeak
mockImplementation will be undefined only if you forget to assign it to jest.fn(). I just testedQr
If you get the mockImplementation is undefined error make sure that your function in jest.mock is wrapped in jest.fn(). For example: methodToMock: jest.fn((x) => x + 1)Commandment
when importing es module, don't forget to add __esModule: true to the mocked objectDelinquency
What if the method to mock is the actual constructor? Can I require the actual module only in some tests?Intension
What if it's not a method, but a constant?Erlanger
Wow. I've learnt something new today. I didnt know you have to setup the mocking before importing the module. After 3 hours fidgeting. ThxMargalo
You should not have to mock before an import any more as jest hoists the jest.mocks now to my understanding. This causes an issue though if you try to create a const outside of the mock to a mocked function to check if that's been called and to provide proper typing. You will need to defer the call to the mocked function. Something like: const mockedFn = jest.fn().mockResolvedValue('url'); jest.mock('@aws-sdk/s3-request-presigner', () => { return { getSignedUrl: jest.fn().mockImplementation(() => mockedFn()) } })Edrisedrock
you saved my life, I was going crazy over thisExhibitor
R
17

I use the following pattern:

'use strict'

const packageToMock = require('../path')

jest.mock('../path')
jest.mock('../../../../../../lib/dmp.db')

beforeEach(() => {
  packageToMock.methodToMock.mockReset()
})

describe('test suite', () => {
  test('test1', () => {
    packageToMock.methodToMock.mockResolvedValue('some value')
    expect(theThingToTest.someAction().type).toBe(types.SOME_TYPE)

  })
  test('test2', () => {
    packageToMock.methodToMock.mockResolvedValue('another value')
    expect(theThingToTest.someAction().type).toBe(types.OTHER_TYPE)
  })
})

Explanation:

You mock the class you are trying to use on test suite level, make sure the mock is reset before each test and for every test you use mockResolveValue to describe what will be return when mock is returned

Race answered 10/3, 2019 at 16:2 Comment(1)
Without the reset, the other solution wasn't working for me! thanksLicentiate
M
12

Another way is to use jest.doMock(moduleName, factory, options).

E.g.

the-package-to-mock.ts:

export function methodToMock() {
  return 'real type';
}

toTest.ts:

import { methodToMock } from './the-package-to-mock';

export function someAction() {
  return {
    type: methodToMock(),
  };
}

toTest.spec.ts:

describe('45006254', () => {
  beforeEach(() => {
    jest.resetModules();
  });
  it('test1', () => {
    jest.doMock('./the-package-to-mock', () => ({
      methodToMock: jest.fn(() => 'type A'),
    }));
    const theThingToTest = require('./toTest');
    expect(theThingToTest.someAction().type).toBe('type A');
  });

  it('test2', () => {
    jest.doMock('./the-package-to-mock', () => ({
      methodToMock: jest.fn(() => 'type B'),
    }));
    const theThingToTest = require('./toTest');
    expect(theThingToTest.someAction().type).toBe('type B');
  });
});

unit test result:

 PASS  examples/45006254/toTest.spec.ts
  45006254
    ✓ test1 (2016 ms)
    ✓ test2 (1 ms)

-----------|---------|----------|---------|---------|-------------------
File       | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
-----------|---------|----------|---------|---------|-------------------
All files  |     100 |      100 |     100 |     100 |                   
 toTest.ts |     100 |      100 |     100 |     100 |                   
-----------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests:       2 passed, 2 total
Snapshots:   0 total
Time:        3.443 s

source code: https://github.com/mrdulin/jest-v26-codelab/tree/main/examples/45006254

Meristic answered 23/2, 2021 at 3:8 Comment(2)
This is good but has only a small drawback, it does not necessarily play nice with ide integrationSurgeon
@Surgeon Which IDE? And what about the integration doesn't work well?Testosterone
J
6

spyOn worked best for us. See previous answer:

https://mcmap.net/q/116360/-how-to-change-mock-implementation-on-a-per-single-test-basis

Jacobs answered 25/1, 2019 at 9:8 Comment(0)
E
3

How to Change Mocked Functions For Different Test Scenarios

In my scenario I tried to define the mock function outside of the jest.mock which will return an error about trying to access the variable before it's defined. This is because modern Jest will hoist jest.mock so that it can occur before imports. Unfortunately this leaves you with const and let not functioning as one would expect since the code hoists above your variable definition. Some folks say to use var instead as it would become hoisted, but most linters will yell at you, so as to avoid that hack this is what I came up with:

Jest Deferred Mocked Import Instance Calls Example

This allows us to handle cases like new S3Client() so that all new instances are mocked, but also while mocking out the implementation. You could likely use something like jest-mock-extended here to fully mock out the implementation if you wanted, rather than explicitly define the mock.

The Problem

This example will return the following error:

eferenceError: Cannot access 'getSignedUrlMock' before initialization

Test File

const sendMock = jest.fn()
const getSignedUrlMock = jest.fn().mockResolvedValue('signedUrl')

jest.mock('@aws-sdk/client-s3', () => {
  return {
    S3Client: jest.fn().mockImplementation(() => ({
      send: sendMock.mockResolvedValue('file'),
    })),
    GetObjectCommand: jest.fn().mockImplementation(() => ({})),
  }
})

jest.mock('@aws-sdk/s3-request-presigner', () => {
  return {
    getSignedUrl: getSignedUrlMock,
  }
})

The Answer

You must defer the call in a callback like so:

getSignedUrl: jest.fn().mockImplementation(() => getSignedUrlMock())

Full Example

I don't want to leave anything up to the imagination, although I phaked the some-s3-consumer from the actual project, but it's not too far off.

Test File

import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3'
import { SomeS3Consumer } from './some-s3-consumer'

const sendMock = jest.fn()
const getSignedUrlMock = jest.fn().mockResolvedValue('signedUrl')

jest.mock('@aws-sdk/client-s3', () => {
  return {
    S3Client: jest.fn().mockImplementation(() => ({
      send: sendMock.mockResolvedValue('file'),
    })),
    GetObjectCommand: jest.fn().mockImplementation(() => ({})),
  }
})

jest.mock('@aws-sdk/s3-request-presigner', () => {
  return {
    // This is weird due to hoisting shenanigans
    getSignedUrl: jest.fn().mockImplementation(() => getSignedUrlMock()),
  }
})

describe('S3Service', () => {
  const service = new SomeS3Consumer()

  describe('S3 Client Configuration', () => {
    it('creates a new S3Client with expected region and credentials', () => {
      expect(S3Client).toHaveBeenCalledWith({
        region: 'AWS_REGION',
        credentials: {
          accessKeyId: 'AWS_ACCESS_KEY_ID',
          secretAccessKey: 'AWS_SECRET_ACCESS_KEY',
        },
      })
    })
  })

  describe('#fileExists', () => {
    describe('file exists', () => {
      it('returns true', () => {
        expect(service.fileExists('bucket', 'key')).resolves.toBe(true)
      })

      it('calls S3Client.send with GetObjectCommand', async () => {
        await service.fileExists('bucket', 'key')

        expect(GetObjectCommand).toHaveBeenCalledWith({
          Bucket: 'bucket',
          Key: 'key',
        })
      })
    })

    describe('file does not exist', () => {
      beforeEach(() => {
        sendMock.mockRejectedValue(new Error('file does not exist'))
      })

      afterAll(() => {
        sendMock.mockResolvedValue('file')
      })

      it('returns false', async () => {
        const response = await service.fileExists('bucket', 'key')

        expect(response).toBe(false)
      })
    })
  })

  describe('#getSignedUrl', () => {
    it('calls GetObjectCommand with correct bucket and key', async () => {
      await service.getSignedUrl('bucket', 'key')

      expect(GetObjectCommand).toHaveBeenCalledWith({
        Bucket: 'bucket',
        Key: 'key',
      })
    })

    describe('file exists', () => {
      it('returns the signed url', async () => {
        const response = await service.getSignedUrl('bucket', 'key')

        expect(response).toEqual(ok('signedUrl'))
      })
    })

    describe('file does not exist', () => {
      beforeEach(() => {
        getSignedUrlMock.mockRejectedValue('file does not exist')
      })

      afterAll(() => {
        sendMock.mockResolvedValue('file')
      })

      it('returns an S3ErrorGettingSignedUrl with expected error message', async () => {
        const response = await service.getSignedUrl('bucket', 'key')

        expect(response.val).toStrictEqual(new S3ErrorGettingSignedUrl('file does not exist'))
      })
    })
  })

})
Edrisedrock answered 5/10, 2022 at 21:8 Comment(0)
V
0

Andreas answer work well with functions, here is what I figured out using it:

// You don't need to put import line after the mock.
import {supportWebGL2} from '../utils/supportWebGL';


// functions inside will be auto-mocked
jest.mock('../utils/supportWebGL');
const mocked_supportWebGL2 = supportWebGL2 as jest.MockedFunction<typeof supportWebGL2>;

// Make sure it return to default between tests.
beforeEach(() => {
  // set the default
  supportWebGL2.mockImplementation(() => true); 
});

it('display help message if no webGL2 support', () => {
  // only for one test
  supportWebGL2.mockImplementation(() => false);

  // ...
});

It won't work if your mocked module is not a function. I haven't been able to change the mock of an exported boolean for only one test :/. My advice, refactor to a function, or make another test file.

export const supportWebGL2 = /* () => */ !!window.WebGL2RenderingContext;
// This would give you: TypeError: mockImplementation is not a function
Vincevincelette answered 13/11, 2020 at 16:2 Comment(0)
P
-1

Just jest.mock default values. 1.

jest.mock('./hooks/useCustom', () => jest.fn(() => value));
// or
jest.mock('./hooks/useCustom');

  1. And in the test that you want to override the default value:
import useCustom from './hooks/useCustom'

it('test smt else', () => {
  useCustom.mockReturnValueOnce(differentValue)
  // with ts: (useCustom as any).mockReturnValueOnce(differentValue)
  // render hook or component
  // expect(...)
})
Procrustean answered 20/1 at 9:1 Comment(0)
C
-1
import React from 'react';
import Component from 'component-to-mock';

jest.mock('component-to-mock', () => jest.fn());

describe('Sample test', () => {
  it('first test', () => {
     Component.mockImplementation(({ props }) => <div>first mock</div>);
  });

  it('second test', () => {
     Component.mockImplementation(({ props }) => <div>second mock</div>);
  });
});
Crowe answered 26/2 at 9:28 Comment(0)

© 2022 - 2024 — McMap. All rights reserved.