Jasmine文档(二)

前言

这是翻译的Jasmine文档第二篇,第一篇文章的地址为:
Jasmine文档(一)

Spies(间谍)

Jasmine有称为间谍(spies)的测试双重功能。一个spy可以监测任何函数的调用和参数的调用痕迹。Spy只能存在于定义它的describe()it()代码块内,而在每一个spec结束后将被移除。(这个语法在Jasmine2.0才改变的)
有几个特别的Matchers于spy相互作用:
toHaveBeenCalled():在spy被调用是返回true;
toHaveBeenCalledTimes():在spy调用指定次数的时候会通过测试;
toHaveBeenCalledWith():如果匹配任一调用的参数列表,则返回true。
例子:

describe("A spy", function() {
  var foo, bar = null;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      }
    };

    spyOn(foo, 'setBar');//使用spyOn()来声明spy

    foo.setBar(123);
    foo.setBar(456, 'another param');
  });
  it("tracks that the spy was called", function() {
    //测试spy是否调用
    expect(foo.setBar).toHaveBeenCalled();
  });
  it("tracks that the spy was called x times", function() {
    //测试spy是否调用两次
    expect(foo.setBar).toHaveBeenCalledTimes(2);
  });
  it("tracks all the arguments of its calls", function() {
    //测试spy调用时的参数列表是否匹配
    expect(foo.setBar).toHaveBeenCalledWith(123);
    expect(foo.setBar).toHaveBeenCalledWith(456, 'another param');
  });

  it("stops all execution on a function", function() {
    //Spy的调用并不会影响真实的值,所以bar仍然是null。
    expect(bar).toBeNull();
  });
});

and.callThrough

Spy通过链式调用and.callThrough,除了追踪所有的调用之外,它将委托实际的实现值。例如:

describe("A spy, when configured to call through", function() {
  var foo, bar, fetchedBar;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      },
      getBar: function() {
        return bar;
      }
    };

    spyOn(foo, 'getBar').and.callThrough();//定义spy并且链式调用and.callThrough()

    foo.setBar(123);
    fetchedBar = foo.getBar();//调用spy
  });

  it("tracks that the spy was called", function() {
    expect(foo.getBar).toHaveBeenCalled();
  });

  it("should not affect other functions", function() {
    expect(bar).toEqual(123);
  });

  it("when called returns the requested value", function() {
    expect(fetchedBar).toEqual(123);//fetchedBar为函数实际返回的值。
  });
});

将上述代码对比于一下代码:

describe("A spy, when configured to call through", function() {
  var foo, bar, fetchedBar;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      },
      getBar: function() {
        return bar;
      }
    };

    spyOn(foo, 'getBar');//不再链式调用and.callThrough()

    foo.setBar(123);
    fetchedBar = foo.getBar();
  });

  it("tracks that the spy was called", function() {
    expect(foo.getBar).toHaveBeenCalled();
  });

  it("should not affect other functions", function() {
    expect(bar).toEqual(123);
  });

  it("when called returns the requested value", function() {
    expect(fetchedBar).toBeUndefined();//此时的fetchedBar不再是函数返回的实际值,而是undefined
  });
});

and.returnValue

Spy通过链式调用and.returnValue,所有调用spy的都将返回一个指定值。例如:

describe("A spy, when configured to fake a return value", function() {
  var foo, bar, fetchedBar;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      },
      getBar: function() {
        return bar;
      }
    };

    spyOn(foo, "getBar").and.returnValue(745);//指定返回745

    foo.setBar(123);
    fetchedBar = foo.getBar();
  });

  it("tracks that the spy was called", function() {
    expect(foo.getBar).toHaveBeenCalled();
  });

  it("should not affect other functions", function() {
    expect(bar).toEqual(123);
  });

  it("when called returns the requested value", function() {
    expect(fetchedBar).toEqual(745);//返回特定值为745
  });
});

and.returnValues

Spy通过链式调用and.returnValues,所有调用该spy的函数都将按顺序返回一些特定的值,直到返回值队列的最后,这之后的所有调用将返回undefined。例如:

describe("A spy, when configured to fake a series of return values", function() {
  var foo, bar;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      },
      getBar: function() {
        return bar;
      }
    };

    spyOn(foo, "getBar").and.returnValues("fetched first", "fetched second");

    foo.setBar(123);
  });

  it("tracks that the spy was called", function() {
    foo.getBar(123);
    expect(foo.getBar).toHaveBeenCalled();
  });

  it("should not affect other functions", function() {
    expect(bar).toEqual(123);
  });

  it("when called multiple times returns the requested values in order", function() {
    expect(foo.getBar()).toEqual("fetched first");//第一次调用,返回队列的第一个值
    expect(foo.getBar()).toEqual("fetched second");//第二次调用,返回队列的第二个值
    expect(foo.getBar()).toBeUndefined();//之后的调用都将返回undefined
  });
});

and.callFake

Spy通过调用and.callFake,所有调用该spy的都将调用其提供的函数,例如:

describe("A spy, when configured with an alternate implementation", function() {
  var foo, bar, fetchedBar;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      },
      getBar: function() {
        return bar;
      }
    };

    spyOn(foo, "getBar").and.callFake(function() {
      return 1001;
    });

    foo.setBar(123);
    fetchedBar = foo.getBar();
  });

  it("tracks that the spy was called", function() {
    expect(foo.getBar).toHaveBeenCalled();
  });

  it("should not affect other functions", function() {
    expect(bar).toEqual(123);
  });

  it("when called returns the requested value", function() {
    expect(fetchedBar).toEqual(1001);
  });
});

and.throwError

Spy链式调用and.throwError,调用该spy的将以一个错误的形式抛出特殊返回值,例如:

describe("A spy, when configured to throw an error", function() {
  var foo, bar;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      }
    };

    spyOn(foo, "setBar").and.throwError("quux");
  });

  it("throws the value", function() {
    expect(function() {
      foo.setBar(123)
    }).toThrowError("quux");
  });
});

and.stub

Spy链式调用以上某一个策略后,可以调用and.stub随时返回之前保存的原始数据,而不进行修改。例如:

describe("A spy", function() {
  var foo, bar = null;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      }
    };

    spyOn(foo, 'setBar').and.callThrough();
  });

  it("can call through and then stub in the same spec", function() {
    foo.setBar(123);//调用策略and.callThrough()所定义的spy
    expect(bar).toEqual(123);//bar数值被修改为123

    foo.setBar.and.stub();//调用and.stub()
    bar = null;

    foo.setBar(123);//调用spy
    expect(bar).toBe(null);//bar不再返回and.callThrough()的实现值
  });
});

其他跟踪属性

任何调用spy的都将被追踪,并且暴露在calls的属性中。
calls属性有:
1. .calls.any():一次都没调用时返回false,一旦调用至少一次就返回true;
2. .calls.count():返回spy调用的次数
3. .calls.argsFor(index):返回第index+1次调用时传递的参数,index从0开始;
4. .calls.allArgs():以数组的形式返回调用时传递的所有参数;
5. .calls.all():以对象形式返回上下文(this),以及所有传递的参数;
6. .calls.mostRecent():以对象形式返回最近一次调用的上下文(this),以及传递的参数;
7. .calls.first():以对象形式返回第一次调用的上下文(this),以及传递的参数;(当检查.calls.all().calls.mostRecent().calls.first()返回的对象时,.object属性指向的是调用该spy的this对象)
8. .calls.reset():清空spy的所有追踪。
上述属性值,例子如下:

describe("A spy", function() {
  var foo, bar = null;

  beforeEach(function() {
    foo = {
      setBar: function(value) {
        bar = value;
      }
    };

    spyOn(foo, 'setBar');
  });
    it("tracks if it was called at all", function() {
    expect(foo.setBar.calls.any()).toEqual(false);

    foo.setBar();

    expect(foo.setBar.calls.any()).toEqual(true);
  });
    it("tracks the number of times it was called", function() {
    expect(foo.setBar.calls.count()).toEqual(0);

    foo.setBar();
    foo.setBar();

    expect(foo.setBar.calls.count()).toEqual(2);
  });
    it("tracks the arguments of each call", function() {
    foo.setBar(123);
    foo.setBar(456, "baz");

    expect(foo.setBar.calls.argsFor(0)).toEqual([123]);
    expect(foo.setBar.calls.argsFor(1)).toEqual([456, "baz"]);
  });
    it("tracks the arguments of all calls", function() {
    foo.setBar(123);
    foo.setBar(456, "baz");

    expect(foo.setBar.calls.allArgs()).toEqual([[123],[456, "baz"]]);
  });
    it("can provide the context and arguments to all calls", function() {
    foo.setBar(123);

    expect(foo.setBar.calls.all()).toEqual([{object: foo, args: [123], returnValue: undefined}]);
  });
    it("has a shortcut to the most recent call", function() {
    foo.setBar(123);
    foo.setBar(456, "baz");

    expect(foo.setBar.calls.mostRecent()).toEqual({object: foo, args: [456, "baz"], returnValue: undefined});
  });
    it("has a shortcut to the first call", function() {
    foo.setBar(123);
    foo.setBar(456, "baz");

    expect(foo.setBar.calls.first()).toEqual({object: foo, args: [123], returnValue: undefined});
  });
    it("tracks the context", function() {
    var spy = jasmine.createSpy('spy');
    var baz = {
      fn: spy
    };
    var quux = {
      fn: spy
    };
    baz.fn(123);
    quux.fn(456);

    //当检查.calls.all(),.calls.mostRecent(),.calls.first()返回的对象时,.object属性指向的是调用该spy的this对象
    expect(spy.calls.first().object).toBe(baz);
    expect(spy.calls.mostRecent().object).toBe(quux);
  });
    it("can be reset", function() {
    foo.setBar(123);
    foo.setBar(456, "baz");

    expect(foo.setBar.calls.any()).toBe(true);

    foo.setBar.calls.reset();

    expect(foo.setBar.calls.any()).toBe(false);
  });
});

Spies:createSpy

如果没有一个函数可以spyOn,jasmine.createSpy可以创建一个“空白”的spy。该spy会像其他间谍一样追踪调用,函数等等,但是在其之后并不会有实际实现的返回值。Spies是JavaScript对象,可以这样使用:

describe("A spy, when created manually", function() {
  var whatAmI;

  beforeEach(function() {
    whatAmI = jasmine.createSpy('whatAmI');

    whatAmI("I", "am", "a", "spy");
  });

  it("is named, which helps in error reporting", function() {
    expect(whatAmI.and.identity()).toEqual('whatAmI');
  });

  it("tracks that the spy was called", function() {
    expect(whatAmI).toHaveBeenCalled();
  });

  it("tracks its number of calls", function() {
    expect(whatAmI.calls.count()).toEqual(1);
  });

  it("tracks all the arguments of its calls", function() {
    expect(whatAmI).toHaveBeenCalledWith("I", "am", "a", "spy");
  });

  it("allows access to the most recent call", function() {
    expect(whatAmI.calls.mostRecent().args[0]).toEqual("I");
  });
});

Spies:createSpyObj

为了创建一个多重spies的模拟,使用jasmine.createSpyObj()并传递一个字符串的数组,将会返回一个对象,对象包括每个字符串绑定的spy属性。例如:

describe("Multiple spies, when created manually", function() {
  var tape;

  beforeEach(function() {
    tape = jasmine.createSpyObj('tape', ['play', 'pause', 'stop', 'rewind']);

    tape.play();
    tape.pause();
    tape.rewind(0);
  });

  it("creates spies for each requested function", function() {
    expect(tape.play).toBeDefined();
    expect(tape.pause).toBeDefined();
    expect(tape.stop).toBeDefined();
    expect(tape.rewind).toBeDefined();
  });

  it("tracks that the spies were called", function() {
    expect(tape.play).toHaveBeenCalled();
    expect(tape.pause).toHaveBeenCalled();
    expect(tape.rewind).toHaveBeenCalled();
    expect(tape.stop).not.toHaveBeenCalled();
  });

  it("tracks all the arguments of its calls", function() {
    expect(tape.rewind).toHaveBeenCalledWith(0);
  });
});

有兴趣的同学可以查看下一篇文章:
Jasmine文档(三)

你可能感兴趣的:(JavaScript,Jasmine)