如何在每个测试的基础上更改模拟实现？

我想通过扩展默认模拟的行为并在下一个测试执行时将其恢复到原始实现来更改每个测试基础上模拟依赖项的实现。

更简单地说，这就是我想要实现的目标：

1. 模拟依赖
2. 在单个测试中更改/扩展模拟实现
3. 执行下一个测试时恢复到原始模拟

我目前正在使用 Jest v21。典型的测试如下所示：

// __mocks__/myModule.js

const myMockedModule = jest.genMockFromModule('../myModule');

myMockedModule.a = jest.fn(() => true);
myMockedModule.b = jest.fn(() => true);

export default myMockedModule;

// __tests__/myTest.js

import myMockedModule from '../myModule';

// Mock myModule
jest.mock('../myModule');

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

describe('MyTest', () => {
  it('should test with default mock', () => {
    myMockedModule.a(); // === true
    myMockedModule.b(); // === true
  });

  it('should override myMockedModule.b mock result (and leave the other methods untouched)', () => {
    // Extend change mock
    myMockedModule.a(); // === true
    myMockedModule.b(); // === 'overridden'
    // Restore mock to original implementation with no side effects
  });

  it('should revert back to default myMockedModule mock', () => {
    myMockedModule.a(); // === true
    myMockedModule.b(); // === true
  });
});

这是我到目前为止所尝试过的：

1. mockFn.mockImplementationOnce(fn)

   it('should override myModule.b mock result (and leave the other methods untouched)', () => {
   
     myMockedModule.b.mockImplementationOnce(() => 'overridden');
   
     myModule.a(); // === true
     myModule.b(); // === 'overridden'
   });
   

   Pros

   • 第一次调用后恢复到原始实现

   Cons

   • 如果测试调用它就会中断b多次
   • 它不会恢复到原始实现，直到b没有被调用（在下一个测试中泄漏）

2. jest.doMock(moduleName, factory, options)

   it('should override myModule.b mock result (and leave the other methods untouched)', () => {
   
     jest.doMock('../myModule', () => {
       return {
         a: jest.fn(() => true,
         b: jest.fn(() => 'overridden',
       }
     });
   
     myModule.a(); // === true
     myModule.b(); // === 'overridden'
   });
   

   Pros

   • 每次测试都明确地重新模拟

   Cons

   • 无法为所有测试定义默认模拟实现
   • 无法扩展默认实现，强制重新声明每个模拟方法

3. 使用 setter 方法进行手动模拟（如所解释的here)

   // __mocks__/myModule.js
   
   const myMockedModule = jest.genMockFromModule('../myModule');
   
   let a = true;
   let b = true;
   
   myMockedModule.a = jest.fn(() => a);
   myMockedModule.b = jest.fn(() => b);
   
   myMockedModule.__setA = (value) => { a = value };
   myMockedModule.__setB = (value) => { b = value };
   myMockedModule.__reset = () => {
     a = true;
     b = true;
   };
   export default myMockedModule;
   

   // __tests__/myTest.js
   
   it('should override myModule.b mock result (and leave the other methods untouched)', () => {
     myModule.__setB('overridden');
   
     myModule.a(); // === true
     myModule.b(); // === 'overridden'
   
     myModule.__reset();
   });
   

   Pros

   • 完全控制模拟结果

   Cons

   • 大量样板代码
   • 难以长期维持

4. jest.spyOn(object, methodName)

   beforeEach(() => {
     jest.clearAllMocks();
     jest.restoreAllMocks();
   });
   
   // Mock myModule
   jest.mock('../myModule');
   
   it('should override myModule.b mock result (and leave the other methods untouched)', () => {
   
     const spy = jest.spyOn(myMockedModule, 'b').mockImplementation(() => 'overridden');
   
     myMockedModule.a(); // === true
     myMockedModule.b(); // === 'overridden'
   
     // How to get back to original mocked value?
   });
   

   Cons

   • 我无法恢复mockImplementation返回到原来的模拟返回值，从而影响接下来的测试

Use 模拟Fn.mockImplementation(fn).

import { funcToMock } from './somewhere';
jest.mock('./somewhere');

beforeEach(() => {
  funcToMock.mockImplementation(() => { /* default implementation */ });
  // (funcToMock as jest.Mock)... in TS
});

test('case that needs a different implementation of funcToMock', () => {
  funcToMock.mockImplementation(() => { /* implementation specific to this test */ });
  // (funcToMock as jest.Mock)... in TS

  // ...
});