我有以下模块要在Jest中进行测试：

// myModule.js

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

export function testFn() {
  otherFn();

  // do other things
}

如上所示，它导出了一些命名函数并重要地testFn使用otherFn。

在Jest中，当我为其编写单元测试时testFn，我想模拟该otherFn函数，因为我不希望输入错误otherFn影响我的单元测试testFn。我的问题是我不确定做到这一点的最佳方法：

// 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()
  });
});

任何帮助/见解表示赞赏。

jest.requireActual()内部使用jest.mock()

jest.requireActual(moduleName)

返回实际模块而不是模拟模块，绕过所有有关该模块是否应接收模拟实施的检查。

例

我更喜欢在您需要并在返回的对象中散布的这种简洁用法：

// 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')
  })
})

在Jest的Manual Mocks文档中（实例末尾）也引用了此方法：

为了确保手动模拟和其实际实现保持同步，jest.requireActual(moduleName)在导出之前，要求在手动模拟中使用实际模块并使用模拟功能对其进行修改可能会很有用。

import m from '../myModule';

对我不起作用，我确实使用过：

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

m.otherFn = jest.fn();

看来我参加这个聚会迟到了，但是可以。

testFn只需otherFn 使用模块进行调用。

如果testFn使用模块调用，otherFn则可以对模块导出进行模拟otherFn并testFn调用该模拟。

这是一个工作示例：

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
  });
});

转译的代码将不允许babel检索所otherFn()引用的绑定。如果使用函数expession，则应该能够实现嘲讽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();

但是，正如前面评论中提到的@kentcdodds一样，您可能不想模拟otherFn()。相反，只需为其编写新规范otherFn()并模拟它进行的所有必要调用即可。

例如，如果otherFn()正在发出http请求...

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

在这里，您可能想根据模拟的http.get实现来模拟和更新您的断言。

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

我知道这是很久以前问过的，但是我遇到了这种情况，终于找到了可行的解决方案。所以我想在这里分享。

对于模块：

// myModule.js

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

export function testFn() {
  otherFn();

  // do other things
}

您可以更改为以下内容：

// myModule.js

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

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

  // do other things
}

将它们导出为常量而不是函数。我认为问题与提升JavaScript和使用const防止该行为有关。

然后在您的测试中，您可以看到以下内容：

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
  });
});

您的模拟现在应该可以正常工作了。

我通过在这里找到的各种答案解决了我的问题：

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
  });
});

在这里的第一个答案之上，您也可以使用babel-plugin-rewire来模拟导入的命名函数。您可以从表面上查看有关命名函数重新接线的部分 。

在这种情况下，直接带来的好处之一就是您不需要更改从函数调用另一个函数的方式。