Mocking specific function in the same module only for specific tests

[throrin19]

Hello,

I have a question with vi and mocking. I search since 3 days and I found zero response or nothing works like I want.

I have this file :

export const getUserFromDb = (email: string) => {
    // ... complicated function with database connection
}

export const getUserFromCache = (email: string) => {
    // ... simple function with redis call
}

export const getUser(email: string) {
    const user = getUserFromCache(email);

    if (!user) {
        return getUserFromDb(email);
    }

    return user;
}

I have 3 parts of test in my file :

• I test the method getUserFromDb : I mock the database and generate the complexe result to see if all works like I want
• I test the method getUserFromCache : I mock redis part and saw if all returns like I want
• I test the method getUser : I want to mock getUserFromCache and getUserFromDb and show if all are called correctly according the use cases.

I have the problem for the third part. I don't find how to do this. I test vi.spyOn, vi.mock, ... and none works. The first is ignored, the second mock at all cases.

How to do that ?

Thanks in advance

[tushar-sg]

we are facing the same issue with mocking exported functions in the same module.

[geoidesic]

Also same problem here. I tried this (doesn't work):

    vi.mock('~/helpers/Utility.js', async (importOriginal) => {
      const mod: object = await importOriginal()
      return {
        ...mod,
        contestOutcomes: vi.fn((outcome) => contestOutcomes.SUCCESS),
      }
    })

    const spy = vi.spyOn(importOriginal, 'contestOutcomes');

[geoidesic]

This worked for me:

describe('Outcome Router', () => {
  it('should call the success method for SUCCESS outcome', async () => {
    vi.mock('~/helpers/Utility.js', async (importOriginal) => {
      const mod: object = await importOriginal()
      return {
        ...mod,
        // replace some exports
        contestOutcome: vi.fn((outcome) => contestOutcomes.SUCCESS),
      }
    })

    // Import contestOutcomes from the mocked "~/helpers/Constants" module
    const { contestOutcome } = await import('~/helpers/Utility.js');

    const effectProcessor = EffectProcessorFactory({ contest: { result: 1 }, sourceResult: 1 }); // Create an instance of your class
    effectProcessor.process();
    expect(contestOutcome).toHaveBeenCalledOnce();
  });

});

[throrin19]

this does not works :(

[lamlamla]

Any update on this issues? I faced this problem recently an found zero workaround on the internet. Maybe the solution is to just separate functions into different files

[throrin19]

But this logic also breaks the logic of development, and you end up with a huge number of "useless" files just to fit in with the tests, but which lose the interest of the logical functional division.

If adding tests means losing readability in the structure of the code, this has a perverse effect.

With this logic, we very often end up with a file corresponding to a function, so named exports are useless, as are several ES module evolutions.

So two solutions :

First solution: we don't factor any more, and we have a macro function with all the logic inside (and thank you for the readability) but we simplify the testing part because we don't have to mock these sub-parts any more.

The other solution is to write the tests directly in the file in question and not take them out of the file, but this makes things even heavier, and you have to use a well-configured builder to remove these parts of the code (and inclusions) when compiling for the runtime environment.

But then, I don't see the gains introduced with ES modules, given the limitations of mocks for testing.

[sheremet-va]

You can introduce such patterns as dependency injection, restructure your architecture to use classes, or just don't unit test implementation details because it's an anti-pattern.

[throrin19]

But classes or dependency injections are not the responses in all cases (It will to fit with the logic of all the project) and in my case, I have to test that, it's not implementation details, it's with logic and I wan't to verify if it's correct for all possible cases. I don't think I'm the only one with this problem between ESM and mocks in unit testing

[throrin19]

I found how to reorganize, sorry for this long discussion. I mix anti-pattern and other stuffs, I change that to simplify this part and have an anti-pattern function (not tested) and others functions i can test.

[Pencilbox]

I have absolutely same issue, I have to test utils file and some functions included other functions, that could not be mocked :-(
It works just if both functions are properties of the same object, but would be great if vitest could do it also out-of-box. And to spread utils file to multiples files it is obvious not the best idea.
Here is my example that works:

// utils.ts
export const someObject = {
  funA,
  funB
}

export function funA(): string {
  return someObject.funB();  
}

// This function we will try to mock
export function funB(): string {
  return 'calling funB';
}

//utils.test.ts
import * as utils from '@/services/utils.ts'

describe('Test mock function', () => {
  test('Test 1', async () => {
    const spy = vi.spyOn(utils.someObject, 'funB');
    spy.mockImplementationOnce(() => 'calling mock function');
    const responce = await utils.someObject.funA();
    console.log(responce); // <= calling mock function
    expect(spy).toHaveBeenCalledTimes(1);
  })
})

Also works using key word this in the utils file:

// utils.ts
export function funA(): string {
  return this.funB();  
}

// This function we will try to mock
export function funB(): string {
  return 'calling funB';
}

//utils.test.ts
import * as utils from '@/services/utils.ts'

describe('Test mock function', () => {
  test('Test 1', async () => {
    const spy = vi.spyOn(utils, 'funB');
    spy.mockImplementationOnce(() => 'calling mock function');
    const responce = await utils.funA();
    console.log(responce); // <= calling mock function
    expect(spy).toHaveBeenCalledTimes(1);
  })
})

[b0tm1nd]

This should be a bug report I guess. Without this working the lib seems useless to me...
Exactly the same issue seems to be with jest.
Where with jest there is an additional workaround to use babel-plugin-rewire without altering any testing functions.
But can't get this plugin to work with vitest.

[codeBelt]

Also ran into this issue but it is mentioned in vitest Mocking Pitfalls docs.

https://vitest.dev/guide/mocking#mocking-pitfalls

[ycfreeman]

i just ran into this exact same issue trying to migrate tests from jest to vitest

works in jest (at least kind of) and old code has a lot of module functions just like that

surely it is a bad practice but it is a major blocker for switching from jest to vitest 😢