如果您仍在使用 Jasmine 1.x，您可能会发现直接跳至最新版本（当前的 5.x）比依次升级到每个主要版本更轻松。尤其是

本升级指南的其余部分或多或少地保留原样，就像在 2.0 发布时一样。

在 jasmine 2.0 发布后发生了许多变化

 
describe("Upgrading to jasmine 2.0", function() {

自定义匹配程序

 
  describe("Custom Matchers", function() {
    beforeEach(function() {

addMatchers 函数不再位于规范 (this) 上，现在位于全局 jasmine 对象上。

 
      /* was:
         this.addMatchers({
      */
      jasmine.addMatchers({

现在设置一个匹配程序有所不同。工厂接收一个 util 对象，其中包含像 jasmines 等值函数和任何已注册的 customEqualityTesters 这样的内容。工厂应返回一个具有 compare 函数的对象，该函数将直接使用 actual 和 expected 调用，而不是在 this 上使用实际值

 
        /* was:
           toBeCustom: function(expected) {
             var passed = this.actual == expected;
        */
        toBeCustom: function(util, customEqualityTesters) {
          return {
            compare: function(actual, expected) {
              var passed = actual == expected

比较现在应该返回一个具有 pass 和 message 属性的对象。

有关使用自定义匹配程序的更多信息。本页面旨在说明将 1.x 套件升级到 2.0 所需的更改

 
              /* was:
                this.message = function() {
                  return [
                    'Expected ' + this.actual + ' to equal ' + expected,
                    'Expected ' + this.actual + ' not to equal ' + expected
                  ];
                };
                return passed;
                });
                */
              return {
                pass: passed,
                message: 'Expected ' + actual + (passed ? '' : ' not') + ' to equal ' + expected
              };
            }
          };
        }
      });
    });

自定义匹配程序的使用保持不变

 
    it("uses custom matchers", function() {
      expect(1).toBeCustom(1);
    });
  });

异步规范

 
  describe("Asynchronous Specs", function() {

我们假设这是异步的，用于我们的以下测试

 
    var asyncSetThing,
    somethingAsyncWithCallback = function(callback) {
      asyncSetThing = true;
      callback();
    };

runs、waits 和 waitsFor 方法已被删除，原因在于允许作为规范的一部分运行的函数接收并调用 done 回调。

 
    /* was:
       it("calls an async thing and waits", function() {
         var asyncDone = false;
         somethingAsyncWithCallback(function() {
           asyncDone = true
         });

虽然过去有必要在规范本身中跟踪异步状态。

 
         waitsFor(function() {
           return asyncDone;
         });
     */

通过使 beforeEach、afterEach 或 it 接收一个 done 回调，jasmine 会等到该函数被调用后再移动到队列中的下一个内容。这意味着如果异步逻辑也接受一个回调以供其完成后使用，jasmines done 可以直接传递，jasmine 将适当地等待。

 
    beforeEach(function(done) {
      somethingAsyncWithCallback(done);
    });

    /*
       runs(function() {
         expect(asyncSetThing).toBeTruthy();
       });
     });
     */
    it("will wait until async completes and calls done", function() {
      expect(asyncSetThing).toBeTruthy();
    });
  });

间谍

 
  describe("Spies", function() {
    it('should spy', function() {
      var spy = jasmine.createSpy('spy');

所有方法不再直接告知间谍该如何表现。现在有一个包含所有间谍行为的 and 属性，因此需要添加到被监视的函数中的属性更少。

 
       /* was:
        spy.andCallThrough();
        spy.andCallFake(function() {});
        spy.andThrow('error');
        spy.andReturn(1);
        */
      spy.and.callThrough();
      spy.and.callFake(function() {});
      spy.and.throwError('error');
      spy.and.returnValue(1);

基本设置和检查仍然相同

 
      spy('foo');
      spy('bar');

      expect(spy).toHaveBeenCalledWith('foo');

与行为类似，更多高级调用检查在 calls 属性中

 
      /* was:
         expect(spy.mostRecentCall.args).toEqual(['bar']);
         expect(spy.callCount).toBe(2);
       */
      expect(spy.calls.mostRecent().args).toEqual(['bar']);
      expect(spy.calls.count()).toBe(2);
    });
  });

时钟

 
  describe("Clock", function() {

jasmine 模拟时钟现在是一个实例化对象，而不是一个全局对象，现在它会被 install 而不是被告知 useMock。

 
    beforeEach(function() {
    /* was:
       jasmine.Clock.useMock();
     */
      jasmine.clock().install();
    });

敲击 ticking 时钟仍然基本相同

 
    it("uses the clock similarly", function() {
      /* was:
         jasmine.Clock.tick();
       */
      jasmine.clock().tick();
    });

jasmine 2.0 移除了插件动态添加 afterEach 回调的能力。为了防止时钟成为一个可以自行卸载的特殊对象，现在需要手动卸载该时钟。

 
    afterEach(function() {
      jasmine.clock().uninstall();
    });
  });
});