jest.clearAllMocks(); does not remove mock implementation within afterEach

[cphoover]

🐛 Bug Report

jest.clearAllMocks(); does not remove mock implementation within afterEach

To Reproduce

I have a file called src/layouts/index.js

// ./src/layouts/index.js
const importAll = (r) =>
    r.keys().reduce(
        (acc, key) => ({
            ...acc,
            [key.replace(/^\.\/(.*).json$/, '$1')]: r(key)
        }),
        {}
    );

module.exports = importAll(require.context('./', true, /\.json$/));

It utilizes webpack require.context so I am trying to mock with jest.mock.

I have another file... say file util.js

//./src/util.js
import layouts from '../layouts';
export const getLayout(name) {
  return layouts[name];
}

in my test I'm trying to clear the mocks after each test

//./src/util.test.js
describe('my test suite', () => {
  afterEach(() => {
     jest.clearAllMocks();
  })
  test('test number one', () => {
      jest.mock('./layouts', () => ({
          layout1 : { a : 1 },
          layout2 : { b: 2 },
     }));
     assert.equals(getLayout('layout1').a, 1);
     assert.equals(getLayout('layout2').b, 2);
  });
  test('test number two', () => {
     assert.equals(getLayout('layout1').a, 1);
     assert.equals(getLayout('layout2').b, 2);
  });
});

Expected behavior

I would expect for the first test to pass and the second test to fail... because the mock should have been cleared.

Link to repl or repo (highly encouraged)

https://repl.it/@CharlieHoover/SorrowfulBackSandboxes

[cphoover]

As I understand the parallel execution model of jest the tests inside each suite are run sequentially so you should be able to mock per individual test.

[cphoover]

FYI The mocking documentation and API is extremely unclear, and overly complicated IMHO.

[rickhanlonii]

jest.clearAllMocks does not remove mock implementations by design - try jest.resetAllMocks

Here are the relevant docs:

[cphoover]

Still does not work with resetAllMocks:

Example included:

https://repl.it/@CharlieHoover/SorrowfulBackSandboxes-2

Aside from that that is extremely ambiguous. Why would a function called clearAllMocks not clear the mocks... Name the function resetMockState or something more descriptive. clearAllMocks implies the mocks are being cleared.

[cphoover]

@rickhanlonii my issue is not yet answered. I want to remove the mocks.

[rickhanlonii]

Ah, yeah, looks like resetAllMocks does not reset mock module factories just the implementations set by mockImplementation. If you want to post what you want to do to stackoverflow I can help you do what you want there but it doesn't look like there's a bug here

Why would a function called clearAllMocks not clear the mocks

I think the confusion is that the "mock" in "clearAllMocks" does not refer to the mock implementations, it refers to the Jest mock objects. So this function means "clear out all jest mock objects" which is to say call .mockClear on all mock objects (i.e. clear the calls)

[ccemeraldeyes]

@rickhanlonii

omg so #1 it seems like "clear" and "reset" are being used opposite to what their logical meaning is.

Also, it's very clear what he's trying to do; remove the mock implementation, and you're saying there's no way to do that orrr.....?????

[ccemeraldeyes]

This should be reopened

[MikeSpitz]

+1

[montezume]

+1

[AlvinLaiPro]

+1

[AlvinLaiPro]

I have a similar issue, when I mock an implementation in previous it case, the next it case will be affected.

[alexwaibel]

+1

[Lagily]

also struggling with this!

[d4nc3r]

+1 please update the docs to explain how to REMOVE a mock/spy

[JimmayVV]

+1 please update the docs to explain how to REMOVE a mock/spy

Isn't this what mockRestore is for? https://jestjs.io/docs/en/mock-function-api#mockfnmockrestore

[damien-roche]

I think the default config should include:

{
  restoreMocks: true,
  clearMocks: true,
  resetMocks: true
} 

It is shocking that the default behaviour is to vomit state between tests. Can you please just keep my tests isolated by default? Then the [hopeful minority] who want to spread state across multiple tests can do so by opt-in.

[ankur20us]

`
describe('test', () => {
beforeEach(() => {
const WelcomeService = require('./../SOME_MODULE')
WelcomeServiceSpyOfMessage = jest.spyOn(
WelcomeService,
'message', // some function I mocked
)
const IsUserAuthentic = require('./../SOME_MODULE')
IsUserAuthenticSpyOnIsUserAuthentic = jest.spyOn(
IsUserAuthentic,
'isUserAuthentic' // some function I mocked
)
app = require('../src/server') // my Express server
})

afterEach(() => {
  jest.restoreAllMocks()
})

it('1. Mock implementation', async () => {
  const mockedMessage = faker.lorem.sentence()
  WelcomeServiceSpyOfMessage.mockImplementation(() => mockedMessage)
  IsUserAuthenticSpyOnIsUserAuthentic.mockImplementation(() => {
    console.log('>>> MOCKED MW 1')
    return true
  })
  const result = await request(app)
    .get('/api')
  expect(result.statusCode).toBe(200)
  expect(result.body).toHaveProperty('message', mockedMessage)
})

it('2. After restored implementation', async () => {
  IsUserAuthenticSpyOnIsUserAuthentic.mockImplementation(() => {
    console.log('>>> MOCKED MW 2')
    return true
  })
  const result = await request(app)
    .get('/api')
  expect(result.statusCode).toBe(200)
  expect(result.body).toHaveProperty('message', 'hello world')
})

})
`
Output:
console.log test/routes.test.js:36
>>> MOCKED MW 1

console.log test/routes.test.js:36
>>> MOCKED MW 1

Same mocked version of function is called for both the tests. Although I have restored all mocks in afterEach call, still same mock is getting called. Please tell me where I missed.

Thanks

[JoaoFGuiomar]

+1 🥂

[TorranceYang]

+1

[vinyoliver]

+1
It seems to me that clearing the mocks after each test should be the default behavior.

[robbporto]

+1
It seems to me that clearing the mocks after each test should be the default behavior.

+1

[joshssarna]

functions mocked with .spyOn() can be restored: jest.spyOn(object, method).mockImplementation(mockFunction).

I agree that mocks should be cleared automatically between tests, though.

[karl-frascari]

+1

[saitho]

+1

[cedricsarigumba]

Is there a fix for this issue? +1

[el-lsan]

Facing the same issue!

[fake364]

has anyone found a fix for this ?
I am passing jest.clearAllMocks resetAllMocks under beforeEach and it definitely is still not clearing the mockImplementation

@SidKhanna296 jest.restoreAllMocks() is the one you're looking for.

damn, I've just struggled too much trying to get why clear or reset mocks don't actually CLEAR and RESET mocks, thank you!!! you are my savior

[RafaelEufrazio]

Shouldn't the clearAllMocks and restoreAllMocks combo work for any use case?

clearAllMocks clears all mock calls
restoreAllMocks restores all mocked implementations to their default (non-mocked) state

The way I see it, the resetAllMocks still keeps mocked implementations as mocks, only without return values or defined implementation.

If I'm wrong here, anyone please correct me

[JRRS1982]

Shouldn't the clearAllMocks and restoreAllMocks combo work for any use case?

clearAllMocks clears all mock calls restoreAllMocks restores all mocked implementations to their default (non-mocked) state

The way I see it, the resetAllMocks still keeps mocked implementations as mocks, only without return values or defined implementation.

If I'm wrong here, anyone please correct me

mockClear clears only data pertaining to mock calls

mockReset resets to mock to its initial implementation.

Have a read of this on SO basically if you change mocks between tests then your mock changes, but the mock is not reset as its not been used (at least my understanding)

resetModules and resetMocks is i think the right setup - keen to get a consensus though.

[RafaelEufrazio]

Shouldn't the clearAllMocks and restoreAllMocks combo work for any use case?
clearAllMocks clears all mock calls restoreAllMocks restores all mocked implementations to their default (non-mocked) state
The way I see it, the resetAllMocks still keeps mocked implementations as mocks, only without return values or defined implementation.
If I'm wrong here, anyone please correct me

mockClear clears only data pertaining to mock calls

mockReset resets to mock to its initial implementation.

Have a read of this on SO basically if you change mocks between tests then your mock changes, but the mock is not reset as its not been used (at least my understanding)

resetModules and resetMocks is i think the right setup - keen to get a consensus though.

As explained in the link you sent, I'm understanding that the mockReset just resets the method to a new jest.fn(), not the original implementation of the method, while the mockRestore restores the original implementation of each method.

I've been using the restoreAllMocks together with the clearAllMocks with that purpose so far, and it has been working great.
Don't know if using resetModules I'd have any advantage though.

[olsonpm]

to get around the issue, here's a pattern that works for and makes sense to me

the issue for me was resetting my mocks to those which are declared in __mocks__ directories. The easiest solution I saw was to reset modules and re-require them before each test. This way resetAllMocks didn't wipe out all the mocks I wanted persisted. Essentially only the one-off mocks I created in the tests are reset.

* the example is in typescript in case anyone has trouble figuring out the syntax there. Using require instead of dynamic import gets around typing nonsense

let's assume I mock fs.stat to return a particular object

// /__mocks__/fs.ts

// here we declare mocks we want persisted
const mockFs = {
  stat = jest.fn(() => ({ size: 100, blocks: 2, ... })
}

export default mockFs

and depend on that mock to test ./do-something.ts

// /do-something.test.ts

// declare 'let' for each dependency
let fs: jest.MockedObject<typeof import('fs')>
let doSomething: typeof import('./do-something')

beforeEach(() => {
  jest.resetAllMocks()
  jest.resetModules()
  
  fs = require('fs').default
  doSomething = jest.requireActual('./do-something').default
})

describe('some block', () => {
  it('should return a 404', () => {
    fs.stat.mockImplementation(() => throw new Error('file not found'))

    doSomething() // will have the mock implementation above
  })
  
  it('should work', () => {
    doSomething() // will have the mock implementation from /__mocks__/fs.ts
  })
})

[RafaelEufrazio]

to get around the issue, here's a pattern that works for and makes sense to me

the issue for me was resetting my mocks to those which are declared in mocks directories. The easiest solution I saw was to reset modules and re-require them before each test. This way resetAllMocks didn't wipe out all the mocks I wanted persisted. Essentially only the one-off mocks I created in the tests are reset.

• the example is in typescript in case anyone has trouble figuring out the syntax there. Using require instead of dynamic import gets around typing nonsense

let's assume I mock fs.stat to return a particular object

// /__mocks__/fs.ts

// here we declare mocks we want persisted
const mockFs = {
  stat = jest.fn(() => ({ size: 100, blocks: 2, ... })
}

export default mockFs

and depend on that mock to test ./do-something.ts

// /do-something.test.ts

// declare 'let' for each dependency
let fs: jest.MockedObject<typeof import('fs')>
let doSomething: typeof import('./do-something')

beforeEach(() => {
  jest.resetAllMocks()
  jest.resetModules()
  
  fs = require('fs').default
  doSomething = jest.requireActual('./do-something').default
})

describe('some block', () => {
  it('should return a 404', () => {
    fs.stat.mockImplementation(() => throw new Error('file not found'))

    doSomething() // will have the mock implementation above
  })
  
  it('should work', () => {
    doSomething() // will have the mock implementation from /__mocks__/fs.ts
  })
})

I think if you used clearAllMocks together with restoreAllMocks you wouldn't need to re-require the dependencies. I may be wrong though, should be tested.

[lucasgcbkhomp]

@SimenB Hi, could you add some labels to this issue? It's a pretty hot topic and is indexed on google, but it seems like it is outside of the radar of those who can assist with this since it is not tagged with anything.

[pke]

I really have to wonder why facebook does not seem to have those problems? How are they testing over there?!
I was always frustrated jest can't execute tests inside a file in random order, like a proper testing framework should be able to do. The reason for that could be this weird, unpredictable mess of mocks.

[JRRS1982]

to get around the issue, here's a pattern that works for and makes sense to me

the issue for me was resetting my mocks to those which are declared in mocks directories. The easiest solution I saw was to reset modules and re-require them before each test. This way resetAllMocks didn't wipe out all the mocks I wanted persisted. Essentially only the one-off mocks I created in the tests are reset.

• the example is in typescript in case anyone has trouble figuring out the syntax there. Using require instead of dynamic import gets around typing nonsense

let's assume I mock fs.stat to return a particular object

// /__mocks__/fs.ts

// here we declare mocks we want persisted
const mockFs = {
  stat = jest.fn(() => ({ size: 100, blocks: 2, ... })
}

export default mockFs

and depend on that mock to test ./do-something.ts

// /do-something.test.ts

// declare 'let' for each dependency
let fs: jest.MockedObject<typeof import('fs')>
let doSomething: typeof import('./do-something')

beforeEach(() => {
  jest.resetAllMocks()
  jest.resetModules()
  
  fs = require('fs').default
  doSomething = jest.requireActual('./do-something').default
})

describe('some block', () => {
  it('should return a 404', () => {
    fs.stat.mockImplementation(() => throw new Error('file not found'))

    doSomething() // will have the mock implementation above
  })
  
  it('should work', () => {
    doSomething() // will have the mock implementation from /__mocks__/fs.ts
  })
})

This is a good imo

[russoedu]

Still can't find a solution.

I'm testing a class instance and I need to mock one of the class functions that is called by another other function in the same class.

I tried all the "clean" methods, even together, in the file (before, after) and in the configs.

Nothing worked.

If I change the order of the tests (so, I first test the function (A) and then I test the other function (B) that uses function A and it works.

Not sure what is wrong with it and how to fix it.

[anoop-jadhav-ui]

beforeEach(() => {
  jest.useFakeTimers();
});
afterEach(() => {
  jest.resetAllMocks();
});

This worked for me !

[jimmygchen]

I think the default config should include:

{
  restoreMocks: true,
  clearMocks: true,
  resetMocks: true
} 

It is shocking that the default behaviour is to vomit state between tests. Can you please just keep my tests isolated by default? Then the [hopeful minority] who want to spread state across multiple tests can do so by opt-in.

^^ this should really be considered.
This problem gets worse when fake timers are used. May be worth adding a clearAllTimers option too.

[pke]

But even this default config does not work reliably :( How is facebook working with such a broken test framework?

[bhushan-patil-official]

` describe('test', () => { beforeEach(() => { const WelcomeService = require('./../SOME_MODULE') WelcomeServiceSpyOfMessage = jest.spyOn( WelcomeService, 'message', // some function I mocked ) const IsUserAuthentic = require('./../SOME_MODULE') IsUserAuthenticSpyOnIsUserAuthentic = jest.spyOn( IsUserAuthentic, 'isUserAuthentic' // some function I mocked ) app = require('../src/server') // my Express server })

afterEach(() => {
  jest.restoreAllMocks()
})

it('1. Mock implementation', async () => {
  const mockedMessage = faker.lorem.sentence()
  WelcomeServiceSpyOfMessage.mockImplementation(() => mockedMessage)
  IsUserAuthenticSpyOnIsUserAuthentic.mockImplementation(() => {
    console.log('>>> MOCKED MW 1')
    return true
  })
  const result = await request(app)
    .get('/api')
  expect(result.statusCode).toBe(200)
  expect(result.body).toHaveProperty('message', mockedMessage)
})

it('2. After restored implementation', async () => {
  IsUserAuthenticSpyOnIsUserAuthentic.mockImplementation(() => {
    console.log('>>> MOCKED MW 2')
    return true
  })
  const result = await request(app)
    .get('/api')
  expect(result.statusCode).toBe(200)
  expect(result.body).toHaveProperty('message', 'hello world')
})

}) ` Output: console.log test/routes.test.js:36 >>> MOCKED MW 1

console.log test/routes.test.js:36 >>> MOCKED MW 1

Same mocked version of function is called for both the tests. Although I have restored all mocks in afterEach call, still same mock is getting called. Please tell me where I missed.

Thanks

I think after whichever test you want to reset/clear the mock, you should add there

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

Because that did the job for me.
Wherever I was mocking modules or making spyOn. I added the afterAll in describe. It worked for me.

[lucasgcbkhomp]

@SimenB would you kindly triage this for us? It's a very old issue that could be either a serious problem or just a documentation task. It remains untagged with no consensus on what it really is.

But even this default config does not work reliably :( How is facebook working with such a broken test framework?

Until we get this issue tagged so it becomes reachable, it will remain a mystery whether or not it's actually bugged or there's a large misunderstanding from lack of documentation. People only end up here because of search engine results.

[agilgur5]

But even this default config does not work reliably :(

Yea I have restoreMocks: true, which according to the mock docs, should call .mockRestore, which should call .mockReset, which should call .mockClear. So only that config should be needed, but it does not seem to perfectly isolate the mocks either; it just restores them prior to the next test.

I've tried calling jest.restoreAllMocks() at the beginning of a test as well as mockFn.mockRestore(), and neither of those worked either.

@SimenB would you kindly triage this for us? It's a very old issue that could be either a serious problem or just a documentation task. It remains untagged with no consensus on what it really is.

@SimenB I reproduced this pretty consistently in ezolenko/rollup-plugin-typescript2#345 (comment) / ezolenko/rollup-plugin-typescript2@01373c1 if that helps with narrowing this down.

At least in my case, basically, if two tests ran in parallel, the top-level mock would have state from both tests, instead of isolated state in each test. The workaround I used for this was to create mocks per-test (i.e. inside each individual test's scope, instead of using a top-level mock). That's in the commit linked above, without that workaround, the tests will fail due to the mock sharing state between parallel tests.

That sounds like possibly correct behavior (given concurrency constraints), but it also sounds like restoreMocks etc are supposed to handle isolating these properly as well; there would be no need for these configuration settings if per-test mocks were required. Or, it's only meant for serially executed tests, which should be explicitly mentioned in the docs, especially since Jest's execution model (when tests are executed in serial vs. parallel) can often be hard to grasp.

[paulmax-os]

@agilgur5 for me jest.restoreAllMocks() is working fine when it's called from within afterEach(). Furthermore I used mockReturnValueOnce() and mockResolvedValueOnce. Maybe this helps?

[agilgur5]

@agilgur5 for me jest.restoreAllMocks() is working fine when it's called from within afterEach().

@paulmax-os restoreMocks: true should theoretically have the same effect as that.
Though it's possible that afterEach has an effect on Jest's concurrency model 🤷

Furthermore I used mockReturnValueOnce() and mockResolvedValueOnce.

I'm not sure that these are related? I don't have a need or use-case for these

[paulmax-os]

@agilgur5 yeah, I just wanted to share a (another) working "solution" for anyone reaching this page. I am using the ...Once() methods in my code, but I think you're right: It should also work without ...Once().

[AyuDevs]

did you find a solution in the end? nothing seems to work

[paulmax-os]

For me it worked in the end by doing this:

let wrapper;

beforeEach(() => {
    wrapper = null;
    jest.clearAllMocks();
})

it('makes bar out of foo', async () => {
    const mockMethod = jest
      .spyOn(Class, 'methodName')
      .mockImplementation();

    wrapper = someActionYouWantToPerform('foo');
    await flushPromises(); // depends on your implementation

    expect(mockMethod).toHaveBeenCalledWith('foo');
});

[haribizohra]

For me the problem was that I had a static property. And the problem happened since they aren't part of the instance and are remembered. I have changed it to a normal class property. and it worked (clearAllMocks), maybe someone else didn't pay attention to this and had the same issue 😊

[bj97301]

my function is still being mocked after calling:

    jest.restoreAllMocks()
    jest.resetAllMocks()
    jest.clearAllMocks()

am i missing something?

[kernwig]

I too can call all three function and set the equivalents in config, and my call counts still retain their increments from one test to the next.

The only thing that works for me to to create new mocks in beforeEach:

import createMockInstance from "jest-create-mock-instance";

describe("MyUnitUnderTest", () => {
  let reservationRepo: jest.Mocked<ReservationRepository>;
  let eventPublisher: jest.Mocked<EventPublisherService>;
  let usecase: MyUnitUnderTest;

  beforeEach(() => {
    reservationRepo = createMockInstance(ReservationRepository);
    eventPublisher = createMockInstance(EventPublisherService);
    usecase = new MyUnitUnderTest(reservationRepo, eventPublisher);
  });

[mattcwebster]

For me the problem was that I had a static property. And the problem happened since they aren't part of the instance and are remembered. I have changed it to a normal class property. and it worked (clearAllMocks), maybe someone else didn't pay attention to this and had the same issue 😊

same here, is there a work around for static properties as we shouldn't have to change our implementation to pass a unit test. Atleast, I never do.

[bajiraonakamoto]

I solve my issue saving the original behavior from my function in another const and after it restore my behavior to original function.

const MyObject = {
  getValue() {
    return 'original value'
  }
}
describe('Test restore original implementation', function () {
  const originalObjectState = {...MyObject}

  test('Mock original function', async function () {
    MyObject.getValue = jest.fn(() => 'mocked value')
    const value = MyObject.getValue()
    expect(value).toBe('mocked value')
  });

  test('Restore original function', async function () {
    MyObject.getValue = originalObjectState.getValue
    const value = MyObject.getValue()
    expect(value).toBe('original value')
  });

});