如果一个 ES6 module直接导出两个函数（不在类、对象等内，只是直接导出问题中的函数）并且一个直接调用另一个，那么该调用不能被模拟。

在这种情况下，funcB 不能嘲笑内funcA代码当前编写方式。

有模拟替换module出口的funcB，但funcA不调用module输出的funcB，它只是调用funcB直接。

惩戒funcB内funcA需要funcA调用module出口的funcB。

这可以通过以下两种方式之一完成：

移动funcB到它自己的module

funcB.js

export const funcB = () => {
  return 'original';
};

helper.js

import { funcB } from './funcB';

export const funcA = () => {
  return funcB();
};

helper.spec.js

import * as funcBModule from './funcB';
import { funcA } from './helper';

describe('helper', () => {

  test('test funcB', () => {
    expect(funcBModule.funcB()).toBe('original');  // Success!
  });

  test('test funcA', () => {
    const spy = jest.spyOn(funcBModule, 'funcB');
    spy.mockReturnValue('mocked');

    expect(funcA()).toBe('mocked');  // Success!

    spy.mockRestore();
  });
});

将module导入自身

“ES6 module自动支持循环依赖”，因此它对importmodule本身完全有效，以便module内的函数可以调用module中其他函数的module导出：

helper.js

import * as helper from './helper';

export const funcA = () => {
  return helper.funcB();
};

export const funcB = () => {
  return 'original';
};

helper.spec.js

import * as helper from './helper';

describe('helper', () => {

  test('test funcB', () => {
    expect(helper.funcB()).toBe('original');  // Success!
  });

  test('test funcA', () => {
    const spy = jest.spyOn(helper, 'funcB');
    spy.mockReturnValue('mocked');

    expect(helper.funcA()).toBe('mocked');  // Success!

    spy.mockRestore();
  });
});

迟到的答案，但这应该有效。此外，您应该在其自己的文件中而不是在“帮助程序”测试中测试 funcB。

import { funcB } from './funcB';
import { funcA } from './helper';

jest.mock('./funcB');

describe('helper', () => {
    test('test funcA', () => {
        const funcBSpy = jest.fn();
        funcB.mockImplementation(() => funcBSpy());
        
        funcA();

        expect(funcBSpy).toHaveBeenCalledTimes(1);
    });
});

import * as helper from 'helper';

    describe('helper', () => {
       it('should test testFuncA', () => {
          const mockTestFuncB = jest.mock();
          // spy on calls to testFuncB and respond with a mock function

           mockTestFuncB.spyOn(helper, 'testFuncB').mockReturnValue(/*your expected return value*/);

          // test logic

          // Restore helper.testFuncB to it's original function
          helper.testFuncB.mockRestore();
       }
    }

我创建了一种名称空间来处理这个问题：

let helper = {}

const funcA = (key) => {
   return helper.funcB(key)
};

const funcB = (key,prop) => {
    return someObj;
};

helper = { funcA, funcB }

module.exports = helper

然后嘲笑是明显的 jest.fn

测试时，您可以执行以下技巧funcA：

1.模拟funcB：

helper.funcB = jest.fn().mockImplementationOnce(() => <your data>);

2.funcB(key)更改为this.funcB(key)

我遇到了同样的问题并且工作了！完整代码：

export const funcA = (key) => {
    return this.funcB(key)
};

export const funcB = (key,prop) => {
    return someObj;
};

测试代码：

import helper from 'helper';

describe('helper', () => {
   test('testFuncB', () => {
       ...
   }
   test('testFuncA', () => {
       helper.funcB = jest.fn().mockImplementationOnce(() => <your data>);
   }
}