Tenho o seguinte módulo que estou tentando testar no Jest:

// myModule.js

export function otherFn() {
  console.log('do something');
}

export function testFn() {
  otherFn();

  // do other things
}

Conforme mostrado acima, ele exporta algumas funções nomeadas e testFnusos importantes otherFn.

De brincadeira, quando estou escrevendo meu teste de unidade para testFn, quero simular a otherFnfunção porque não quero que erros no otherFnafetem meu teste de unidade para testFn. Meu problema é que não tenho certeza da melhor maneira de fazer isso:

// myModule.test.js
jest.unmock('myModule');

import { testFn, otherFn } from 'myModule';

describe('test category', () => {
  it('tests something about testFn', () => {
    // I want to mock "otherFn" here but can't reassign
    // a.k.a. can't do otherFn = jest.fn()
  });
});

Qualquer ajuda / visão é apreciada.

Use jest.requireActual()dentrojest.mock()

jest.requireActual(moduleName)

Retorna o módulo real em vez de uma simulação, ignorando todas as verificações sobre se o módulo deve receber uma implementação simulada ou não.

Exemplo

Prefiro esse uso conciso, onde você exige e espalha dentro do objeto retornado:

// myModule.test.js

jest.mock('./myModule.js', () => (
  {
    ...(jest.requireActual('./myModule.js')),
    otherFn: jest.fn()
  }
))

import { otherFn } from './myModule.js'

describe('test category', () => {
  it('tests something about otherFn', () => {
    otherFn.mockReturnValue('foo')
    expect(otherFn()).toBe('foo')
  })
})

Este método também é referenciado na documentação do Manual Mocks de Jest (próximo ao final dos Exemplos ):

Para garantir que um mock manual e sua implementação real fiquem em sincronia, pode ser útil exigir que o módulo real seja usado jest.requireActual(moduleName)em seu mock manual e corrigí-lo com funções mock antes de exportá-lo.

import m from '../myModule';

Não funciona para mim, eu usei:

import * as m from '../myModule';

m.otherFn = jest.fn();

Parece que estou atrasado para esta festa, mas sim, isso é possível.

testFnsó precisa chamar otherFn usando o módulo .

Se testFnusar o módulo para chamar otherFn, a exportação do módulo para otherFnpode ser testFnsimulada e chamará a simulação.

Aqui está um exemplo prático:

myModule.js

import * as myModule from './myModule';  // import myModule into itself

export function otherFn() {
  return 'original value';
}

export function testFn() {
  const result = myModule.otherFn();  // call otherFn using the module

  // do other things

  return result;
}

myModule.test.js

import * as myModule from './myModule';

describe('test category', () => {
  it('tests something about testFn', () => {
    const mock = jest.spyOn(myModule, 'otherFn');  // spy on otherFn
    mock.mockReturnValue('mocked value');  // mock the return value

    expect(myModule.testFn()).toBe('mocked value');  // SUCCESS

    mock.mockRestore();  // restore otherFn
  });
});

O código transpilado não permitirá que o babel recupere o vínculo ao qual otherFn()está se referindo. Se você usar uma expessão de função, deverá conseguir realizar a simulação otherFn().

// myModule.js
exports.otherFn = () => {
  console.log('do something');
}

exports.testFn = () => {
  exports.otherFn();

  // do other things
}

// myModule.test.js
import m from '../myModule';

m.otherFn = jest.fn();

Mas, como @kentcdodds mencionou no comentário anterior, você provavelmente não gostaria de zombar otherFn(). Em vez disso, basta escrever uma nova especificação otherFn()e simular todas as chamadas necessárias que ele está fazendo.

Por exemplo, se otherFn()estiver fazendo uma solicitação http ...

// myModule.js
exports.otherFn = () => {
  http.get('http://some-api.com', (res) => {
    // handle stuff
  });
};

Aqui, você deseja simular http.gete atualizar suas asserções com base em suas implementações simuladas .

// myModule.test.js
jest.mock('http', () => ({
  get: jest.fn(() => {
    console.log('test');
  }),
}));

Sei que isso foi perguntado há muito tempo, mas me deparei com essa mesma situação e finalmente encontrei uma solução que funcionaria. Então eu pensei em compartilhar aqui.

Para o módulo:

// myModule.js

export function otherFn() {
  console.log('do something');
}

export function testFn() {
  otherFn();

  // do other things
}

Você pode alterar o seguinte:

// myModule.js

export const otherFn = () => {
  console.log('do something');
}

export const testFn = () => {
  otherFn();

  // do other things
}

exportá-los como constantes em vez de funções. Eu acredito que o problema tem a ver com o içamento em JavaScript e o uso de constprevenir esse comportamento.

Então, em seu teste, você pode ter algo como o seguinte:

import * as myModule from 'myModule';


describe('...', () => {
  jest.spyOn(myModule, 'otherFn').mockReturnValue('what ever you want to return');

  // or

  myModule.otherFn = jest.fn(() => {
    // your mock implementation
  });
});

Seus mocks agora devem funcionar como você normalmente esperaria.

Resolvi meu problema com uma combinação das respostas que encontrei aqui:

myModule.js

import * as myModule from './myModule';  // import myModule into itself

export function otherFn() {
  return 'original value';
}

export function testFn() {
  const result = myModule.otherFn();  // call otherFn using the module

  // do other things

  return result;
}

myModule.test.js

import * as myModule from './myModule';

describe('test category', () => {
  let otherFnOrig;

  beforeAll(() => {
    otherFnOrig = myModule.otherFn;
    myModule.otherFn = jest.fn();
  });

  afterAll(() => {
    myModule.otherFn = otherFnOrig;
  });

  it('tests something about testFn', () => {
    // using mock to make the tests
  });
});

Além da primeira resposta aqui, você pode usar o babel-plugin-rewire para simular a função nomeada importada também. Você pode verificar a seção superficialmente para religamento de funções nomeadas .

Um dos benefícios imediatos para sua situação aqui é que você não precisa alterar como você chama a outra função de sua função.