Javascript 有没有办法跟茉莉核实间谍处决的顺序？

我有两件物品被设置为Jasmine的间谍：

spyOn(obj, 'spy1');
spyOn(obj, 'spy2');

我需要验证对

spy1

的调用是否在对

spy2

的调用之前。我可以检查它们是否都被调用：

expect(obj.spy1).toHaveBeenCalled();
expect(obj.spy2).toHaveBeenCalled();

---

但是，即使先调用了

obj.spy2（）

，这也会通过。有没有一种简单的方法来验证一个是在另一个之前被调用的？

到目前为止，我一直在做以下工作，但这似乎很尴尬，而且无法很好地扩展：

obj.spy1.andCallFake(function() {
    expect(obj.spy2.calls.length).toBe(0);
});

---

另一种选择是保留通话列表：

var objCallOrder;
beforeEach(function() {
  // Reset the list before each test
  objCallOrder = [];
  // Append the method name to the call list
  obj.spy1.and.callFake(function() { objCallOrder.push('spy1'); });
  obj.spy2.and.callFake(function() { objCallOrder.push('spy2'); });
});

您可以通过以下几种不同的方式检查订单：

直接与通话列表比较：

it('calls exactly spy1 then spy2', function() {
  obj.spy1();
  obj.spy2();

  expect(objCallOrder).toEqual(['spy1', 'spy2']);
});

it('calls spy2 sometime after calling spy1', function() {
  obj.spy1();
  obj.spy3();
  obj.spy4(); 
  obj.spy2();

  expect(obj.spy1).toHaveBeenCalled();
  expect(obj.spy2).toHaveBeenCalled();
  expect(objCallOrder.indexOf('spy1')).toBeLessThan(objCallOrder.indexOf('spy2'));
});

Name        Type    Description
expected    Spy     Spy that should have been called after the actual Spy.

检查几个呼叫的相对顺序：

it('calls exactly spy1 then spy2', function() {
  obj.spy1();
  obj.spy2();

  expect(objCallOrder).toEqual(['spy1', 'spy2']);
});

it('calls spy2 sometime after calling spy1', function() {
  obj.spy1();
  obj.spy3();
  obj.spy4(); 
  obj.spy2();

  expect(obj.spy1).toHaveBeenCalled();
  expect(obj.spy2).toHaveBeenCalled();
  expect(objCallOrder.indexOf('spy1')).toBeLessThan(objCallOrder.indexOf('spy2'));
});

Name        Type    Description
expected    Spy     Spy that should have been called after the actual Spy.

---

看起来茉莉花的人看到了这篇文章或者其他人喜欢它，因为。我不确定它已经存在多久了——他们所有的API文档回到2.6都提到了它，尽管他们归档的老式文档都没有提到它

之前已被调用（

预期值

）
在另一个之前调用的实际值（a）

参数：

it('calls exactly spy1 then spy2', function() {
  obj.spy1();
  obj.spy2();

  expect(objCallOrder).toEqual(['spy1', 'spy2']);
});

it('calls spy2 sometime after calling spy1', function() {
  obj.spy1();
  obj.spy3();
  obj.spy4(); 
  obj.spy2();

  expect(obj.spy1).toHaveBeenCalled();
  expect(obj.spy2).toHaveBeenCalled();
  expect(objCallOrder.indexOf('spy1')).toBeLessThan(objCallOrder.indexOf('spy2'));
});

Name        Type    Description
expected    Spy     Spy that should have been called after the actual Spy.

---

您的示例的失败看起来像是

在spy spy2之前调用了spy spy1

我认为这很有效，无论如何我想不出更好的通用方法。不过，让您的意图更清楚的是这种微妙的变化：

obj.spy1.andCallFake（function（）{expect（obj.spy2.not.tohavebeencall（）}）（在Jasmine v2中是：
obj.spy1.and.callFake（函数（）{expect（obj.spy2.not.toHaveBeenCalled（）}）；
）