返回结果后调用的 jest.spyOn 函数

Question

考虑我们有一些方法的类。我们想监视方法 B 是否被调用，而一旦执行方法 A 将返回结果给调用者，方法 B 将异步执行。该类如下所示。

class Parent {
    constructor() {
        this.conf = [{ id:'1', func: Parent.methodA.bind(Parent)}, { id:'2', func: Parent.methodB.bind(Parent)}]
    }
    static methodA() {
        console.log('methodA is called from methodC');
        return 'methodA';
    }
    static methodB() {
        console.log('methodB is called from methodC');
        return 'methodB';
    }
    methodC(conf) {
        conf.forEach((eachConf) => {
            if(eachConf.id === '1') {
                setImmediate(() => {
                    // Just to call method with conf = [{ id:'2', func: this.methodB.bind(this)}]
                    this.methodC(conf.slice(1));
                })
                return eachConf.func();
            }
            return eachConf.func();
        });
    }
}
module.exports = Parent;

在 jest 测试文件中，调用 methodC 并希望确保 methodA 具有返回值并希望确保 methodB 也被调用。 testSpy.js const Parent = require('./parent');

it('check methodA and methodB called', async () => {
    const methodA = jest.spyOn(Parent, 'methodA');
    const methodB = jest.spyOn(Parent, 'methodB');
    const instance = new Parent();
    instance.methodC(instance.conf);
    expect(methodA).toHaveBeenCalled();
    //How to spyOn methodB.
    //expect(methodB).toHaveBeenCalled();
});

返回结果后可以运行多个方法。想要确保所有的都被执行，最好也能得到每一步的结果。

Answer 1

.bind creates a new function 所以func 设置为this.methodA.bind(this) 创建的新函数。

当jest.spyOn(Parent, 'methodA'); 运行时，它会将methodA 替换为间谍，但这对func 没有任何影响。

当func 被调用时，新函数被调用，methodA 上的间谍永远不会被调用。

---

如果您想使用spy 来验证是否调用了methodA，则必须确保调用它。

在这种情况下，您可以在箭头函数中调用this.methodA，而不是使用bind（创建一个新函数）将methodA绑定到this（因为箭头函数capture the this of the enclosing lexical scope...in这种情况下，来自构造函数的this）：

constructor() {
  this.conf = [
    {
      id: '1',
      func: (...args) => this.methodA(...args)
    },
    {
      id: '2',
      func: (...args) => this.methodB(...args)
    }
  ];
}

然后当func 被调用时，它会调用methodA，而methodA 将调用spy 并且测试将通过。

---

更新

这是您更新后的代码示例的工作测试：

it('check methodA and methodB called', async () => {
  jest.useFakeTimers();
  const methodA = jest.spyOn(Parent, 'methodA');
  const methodB = jest.spyOn(Parent, 'methodB');
  const instance = new Parent();
  instance.methodC(instance.conf);
  jest.runAllTimers();
  expect(methodA).toHaveBeenCalledTimes(1);  // SUCCESS
  expect(methodB).toHaveBeenCalledTimes(2);  // SUCCESS
});

jest.useFakeTimers 用可以记住它们被调用的模拟替换像 setImmediate 这样的计时器函数。然后jest.runAllTimers 运行所有使用计时器函数安排的回调。

methodA 在第一次调用 methodC 时被调用。

methodB 在第一次调用 methodC 时被调用，并且在由于 setImmediate 回调而再次调用 methodC 时也被调用。

Answer 2

当您使用setImmediate 时，您需要使用jest.useFakeTimers() 和jest.runAllTimers() 来立即调用您放入setImmediate 的每个回调。

it('check methodA and methodB called', async () => {
    jest.useFakeTimers()
    const methodA = jest.spyOn(Parent, 'methodA');
    const methodB = jest.spyOn(Parent, 'methodB');
    Parent.methodC(Parent.conf);
    jest.runAllTimers()
    expect(methodA).toHaveBeenCalled();
    //How to spyOn methodB.
    //expect(methodB).toHaveBeenCalled();
});