顺应初学jasmine者,官网地址

【转】应用 Jasmine 举行测试驱动的 JavaScript 开发

写在前面

本文仲介绍壹些jasmine的基本概念和语法,并提交简单易懂的示范。适合初学jasmine者,如若您曾经触发并应用过jasmine,恐怕并不太相符你

(原文:http://www.cnblogs.com/haogj/p/4778808.html)

图片 1

Jasmine 为 JavaScript 提供了 TDD
(测试驱动开发)的框架,对于前端软件开发提供了特出的成色担保,那里对
Jasmine 的布署和使用做3个注明。

眼前,Jasmine 的流行版本是 二.3 版,那里以 2.三版举行求证。网上早就有1部分有关 Jasmine的资料,不过,有个别质感相比较深入,已经与存活版本不一致。所以,那里越发以最新版展开求证。

Jasmine 前端单元测试框架

Jasmine是面向行为使得开发(BDD)的Javascript单元测试框架。它不依靠于其余任何javascript框架,语法清晰简单,很不难上手写出测试代码

  • BDD 行为驱动开发,是1种新的火速开发方法。相对于TDD(测试驱动开发),它更趋向于供给,须求共同利益者的参加,强调用户故事和作为;是面向开发者、QA、非技术人士或商业参加者共同参加和清楚的费用活动,而不是TDD不难地只关怀开发者的方法论;
  • TDD测试驱动开发,是壹种差别于古板软件开发流程:开发甘休再测试加入的风尚开发方法。须求把品种按职能点划分,在编排每种作用点前先编写制定测试代码,然后再编辑使测试通过的效益代码,通过测试来推动整个开发工作。

设若你想深刻摸底BDD和TDD:
可阅览下有关前端开发谈谈单元测试那篇小说,其余整理了焦点书籍,推荐给大家:

  • 测试驱动开发byExample
  • 测试驱动开发的法子

1. 下载

官网地址:http://jasmine.github.io/

官网文书档案地址:http://jasmine.github.io/2.3/introduction.html

下载地址:https://github.com/jasmine/jasmine/releases

在 GitHub
上提供了独立版本 jasmine-standalone-2.3.4.zip 和源码版本,倘诺应用以来,直接利用
standalone 版本即可。

解压之后,能够收获如下所示的公文结构。

图片 2

其中,lib 中是 Jasmine 的贯彻文件,在 lib/jasmine-2.三.四文件夹中,能够看出如下的公文。

图片 3

开辟最外层的 SpecRunner.html ,那是多少个 Jasmine的沙盘,个中提供了测试的示范,大家能够在使用中一贯套用那个模板。在那之中的内容为:

图片 4

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Jasmine Spec Runner v2.3.4</title>

  <link rel="shortcut icon" type="image/png" href="lib/jasmine-2.3.4/jasmine_favicon.png">
  <link rel="stylesheet" href="lib/jasmine-2.3.4/jasmine.css">

  <script src="lib/jasmine-2.3.4/jasmine.js"></script>
  <script src="lib/jasmine-2.3.4/jasmine-html.js"></script>
  <script src="lib/jasmine-2.3.4/boot.js"></script>

  <!-- include source files here... -->
  <script src="src/Player.js"></script>
  <script src="src/Song.js"></script>

  <!-- include spec files here... -->
  <script src="spec/SpecHelper.js"></script>
  <script src="spec/PlayerSpec.js"></script>

</head>

<body>
</body>
</html>

图片 5

能够看看里边引用了 lib/jasmine-二.叁.4/jasmine.js, lib/jasmine-二.三.4/jasmine-html.js
和 lib/jasmine-二.3.4/boot.js 七个系统文件,个中 boot.js
是网页情状下的启航文件,在 张丹 的 jasmine行为使得,测试先行 那篇文章中,要写二个report.js 的开发银行脚本,那里曾经毫无了,直接运用 boot.js 就能够。

页面上边引用的  src/Player.js 和 src/Song.js
是大家的测试对象,而 spec/SpecHelper.js 和 spec/PlayerSpec.js
则是八个照应的测试文件,测试用例就定义在 spec 中。

学习jasmine

二. 测试的定义

咱俩照旧一贯看示例,

一个是 Song.js,那里定义了叁个 Song
的类,通过原型定义了叁个persistFavoriteStatus
实例方法,注意,这里还并未有兑现,假使调用则会抛出非凡。脚本如下。

图片 6

function Song() {
}

Song.prototype.persistFavoriteStatus = function(value) {
  // something complicated
  throw new Error("not yet implemented");
};

图片 7

除此以外叁个是 player.js,定义了 Player 类,定义了三个艺人,通过原型定义了
play, pause, resume 和 makeFavorite 实例方法。对象有3个 isPlaying
的情景,当中 resume 还尚未完毕。

图片 8

function Player() {
}
Player.prototype.play = function(song) {
  this.currentlyPlayingSong = song;
  this.isPlaying = true;
};

Player.prototype.pause = function() {
  this.isPlaying = false;
};

Player.prototype.resume = function() {
  if (this.isPlaying) {
    throw new Error("song is already playing");
  }

  this.isPlaying = true;
};

Player.prototype.makeFavorite = function() {
  this.currentlyPlayingSong.persistFavoriteStatus(true);
};

图片 9

下边看测试的定义,具体育项目检查测试试的阐明,直接加在注释中。

图片 10

describe("Player", function() {
  var player;
  var song;

  beforeEach(function() {
    player = new Player();
    song = new Song();
  });

  // 检测正在歌手进行的歌曲确实是指定的歌曲
  it("should be able to play a Song", function() {
    player.play(song);
    expect(player.currentlyPlayingSong).toEqual(song);

    //demonstrates use of custom matcher
    expect(player).toBePlaying(song);
  });

  // 进行测试的分组,这里测试暂停状态
  describe("when song has been paused", function() {
    beforeEach(function() {
      player.play(song);
      player.pause();
    });

    // isPlaying 的状态检测
    it("should indicate that the song is currently paused", function() {
      expect(player.isPlaying).toBeFalsy();

      // demonstrates use of 'not' with a custom matcher
      // 
      expect(player).not.toBePlaying(song);
    });

    // 恢复
    it("should be possible to resume", function() {
      player.resume();
      expect(player.isPlaying).toBeTruthy();
      expect(player.currentlyPlayingSong).toEqual(song);
    });
  });

  // demonstrates use of spies to intercept and test method calls
  // 使用 spyOn 为对象创建一个 mock 函数
  it("tells the current song if the user has made it a favorite", function() {
    spyOn(song, 'persistFavoriteStatus');

    player.play(song);
    player.makeFavorite();

    expect(song.persistFavoriteStatus).toHaveBeenCalledWith(true);
  });

  //demonstrates use of expected exceptions
  // 异常检测
  describe("#resume", function() {
    it("should throw an exception if song is already playing", function() {
      player.play(song);

      expect(function() {
        player.resume();
      }).toThrowError("song is already playing");
    });
  });
});

图片 11

利用浏览器直接打开 SpenRunner.html 看到的结果

图片 12

能够看到测试都因此了。

若果我们将第二个测试 expect(player.currentlyPlayingSong).toEqual(song);
改成 expect(player.currentlyPlayingSong).toEqual( 1 );

测试通可是,展现会成为那样。

图片 13

jasmine学习环境搭建

在起头读书jasmine从前,搭建1个测试jasmine语法的学习环境是很有须求的,但实际支出中不引入应用这样的环境

 3. 语法

获取安装包

能够在开源社区github上下载
jasmine-standalone-2.4.1.zip;

3.1 describe 和 it

describe
用来对测试用例进行分组,分组可以嵌套,每一种分组能够有1个讲述表达,那几个注脚将会见世在测试结果的页面中。

describe("Player", function() {
      describe("when song has been paused", function() {

而 it
正是测试用例,每一种测试用例有二个字符串的证实,匿名函数内便是测试内容。

  // 检测正在歌手进行的歌曲确实是指定的歌曲
  it("should be able to play a Song", function() {
    player.play(song);
    expect(player.currentlyPlayingSong).toEqual(song);
  });

测试结果的断言使用 expect 举办,函数内提供测试的值,toXXX
中则是愿意的值。

地点的测试使用 toEqual 实行相等断言判断。

陈设安装

下载后解压.zip压缩包,获得如下的目录结构:

图片 14

jasmine安装包解压后目录结构

  • lib目录下富含的jasmine的源代码,把他们(jasmine.css,jasmine.js,jasmine-html.js)引入页面中,就布局了三个jasmine的运营器(Runner);
  • 付出基于jasmine的测试用例并再引进到jasmine的运维器(页面)中,就起来测试工作了。

  <link rel="shortcut icon" type="image/png" href="lib/jasmine-2.4.1/jasmine_favicon.png">
  <link rel="stylesheet" type="text/css" href="lib/jasmine-2.4.1/jasmine.css">
  <script type="text/javascript" src="lib/jasmine-2.4.1/jasmine.js"></script>
  <script type="text/javascript" src="lib/jasmine-2.4.1/jasmine-html.js"></script>

sepc,src
和SpecRunner.html是jasmine的一个官方完整example,使用浏览器直接打开SpecRunner.html就能够看出example的测试结果

3.2 beforeEach 和 afterEach

演示中还应运而生了 beforeEach。

图片 15

  var player;
  var song;

  beforeEach(function() {
    player = new Player();
    song = new Song();
  });

图片 16

顾名思义,它意味着在本组的种种测试在此之前须要展开的备选工作。在大家那边的测试中,总要用到
player 和 song 那八个对象实例,使用 forEach
保险在各样测试用例执行在此之前,重新对那多个目的开始展览了先导化。

afterEach 会在每一个测试用例执行之后执行。

jasmine语法介绍

开卷上例SpecRunner,你应当有了有关jasmine测试用例怎么着去写的难题,带着题材来学习下jasmine的语法是再好可是的法子了

三.3 自定义的预见

除了系统定义的 toEqual
等等断言之外,也能够选用自定义的预感,在上边的示范中就涌出了 toBePlaying
断言。

    //demonstrates use of custom matcher
    expect(player).toBePlaying(song);

以此自定义的预感定义在 SpecHelper.js 文件中。

图片 17

beforeEach(function () {
  jasmine.addMatchers({
    toBePlaying: function () {
      return {
        compare: function (actual, expected) {
          var player = actual;

          return {
            pass: player.currentlyPlayingSong === expected && player.isPlaying
          };
        }
      };
    }
  });
});

图片 18

中间调用了 jasmine 的 addMatchers 函数举行定义,原来此地不叫断言,称为
matcher ,相当于相配器。

预见是四个函数,再次回到贰个对象,当中有三个 compare
的函数,这一个函数接收八个参数,第3个是实际值,第四个为愿意的值。具体的预感逻辑自身定义,那里相比较明星演唱的靶子是否为大家传递的对象,并且明星的情状为正在表演中。

断言函数供给回到二个目的,对象的 pass 属性为二个 boolean
值,表示是或不是由此。

describe方法

describe是jasmine用于描述测试集(Test
Suite)的全局函数,平日有四个参数,五个字符串String,2个方法function;字符串用来描述Test
suite,function里的代码就是测试代码,表示二个测试集合;
1个测试集合能够包括多个spec(测试点)

describe("A suite",function(){
      it("contains spec with an expectation",function(){
            expect(true).toBe(true);
       })
})

四. 常用断言

4.1 toEqual

深相等,对于指标的话,会比较对象的每一种属性。对于数组来说,会相比数组中各种成分。

图片 19

  describe("The 'toEqual' matcher", function() {

    it("works for simple literals and variables", function() {
      var a = 12;
      expect(a).toEqual(12);
    });

    it("should work for objects", function() {
      var foo = {
        a: 12,
        b: 34
      };
      var bar = {
        a: 12,
        b: 34
      };
      expect(foo).toEqual(bar);
    });
  });

图片 20

 

4.2 toBe

对于目的,引用相等。对于值,值格外。

pass: actual === expected

例如

  it("and has a positive case", function() {
    expect(true).toBe(true);
  });

 

4.3 toBeTruthy

是还是不是为真。

  it("The 'toBeTruthy' matcher is for boolean casting testing", function() {
    var a, foo = "foo";

    expect(foo).toBeTruthy();
    expect(a).not.toBeTruthy();
  });

 

4.4 toBeFalsy

是还是不是为假。

  it("The 'toBeFalsy' matcher is for boolean casting testing", function() {
    var a, foo = "foo";

    expect(a).toBeFalsy();
    expect(foo).not.toBeFalsy();
  });

 

4.5 toBeDefined

是否定义过

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

 

4.6 toBeUndefined

未有概念

图片 21

  it("The `toBeUndefined` matcher compares against `undefined`", function() {
    var a = {
      foo: "foo"
    };

    expect(a.foo).not.toBeUndefined();
    expect(a.bar).toBeUndefined();
  });

图片 22

 

4.7 toBeNull

图片 23

  it("The 'toBeNull' matcher compares against null", function() {
    var a = null;
    var foo = "foo";

    expect(null).toBeNull();
    expect(a).toBeNull();
    expect(foo).not.toBeNull();
  });

图片 24

 

4.9 toBeGreaterThan

图片 25

  it("The 'toBeGreaterThan' matcher is for mathematical comparisons", function() {
    var pi = 3.1415926,
      e = 2.78;

    expect(pi).toBeGreaterThan(e);
    expect(e).not.toBeGreaterThan(pi);
  });

图片 26

 

4.10 toBeLessThan

图片 27

  it("The 'toBeLessThan' matcher is for mathematical comparisons", function() {
    var pi = 3.1415926,
      e = 2.78;

    expect(e).toBeLessThan(pi);
    expect(pi).not.toBeLessThan(e);
  });

图片 28

 

4.11 toBeCloseTo

图片 29

  it("The 'toBeCloseTo' matcher is for precision math comparison", function() {
    var pi = 3.1415926,
      e = 2.78;

    expect(pi).not.toBeCloseTo(e, 2);
    expect(pi).toBeCloseTo(e, 0);
  });

图片 30

 

4.12 toContain

集合中是或不是含有。

  it("The 'toContain' matcher is for finding an item in an Array", function() {
    var a = ["foo", "bar", "baz"];

    expect(a).toContain("bar");
    expect(a).not.toContain("quux");
  });

 

4.13 toMatch

正则表明式的合营

图片 31

  it("The 'toMatch' matcher is for regular expressions", function() {
    var message = "foo bar baz";

    expect(message).toMatch(/bar/);
    expect(message).toMatch("bar");
    expect(message).not.toMatch(/quux/);
  });

图片 32

 

4.14 toThrow

检验是不是抛出分外

图片 33

  it("The 'toThrow' matcher is for testing if a function throws an exception", function() {
    var foo = function() {
      return 1 + 2;
    };
    var bar = function() {
      return a + 1;
    };

    expect(foo).not.toThrow();
    expect(bar).toThrow();
  });

图片 34

 

4.15 toHaveBeenCalled

4.16 toHaveBeenCalledWith

是否调用过。

图片 35

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

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

    spyOn(foo, 'setBar');

    foo.setBar(123);
    foo.setBar(456, 'another param');
  });

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

  it("tracks all the arguments of its calls", function() {
    expect(foo.setBar).toHaveBeenCalledWith(123);
    expect(foo.setBar).toHaveBeenCalledWith(456, 'another param');
  });

  it("stops all execution on a function", function() {
    expect(bar).toBeNull();
  });
});
it方法

jasmine使用it来定义spec(测试点),it方法很像describe,同样有五个参数,二个String,2个function。String用来叙述测试点(spec),function正是现实性的测试代码;
二个测试点(sepc)能够包含多少个expectations(断言)

expectations

断言以expect语句来代表,重返ture或false;
expect有3个参数,
代表测试的实际值,它和象征非凡规则的Matcher链接在联合署名,Matcher带有期望值;
成套的断言再次来到true,那一个测试点才通过,只要有三个预见再次回到false,测试点不通过

describe("A suite is just a function",function(){
     var a;
     var b;
     it("and so is a spec",function(){
        a=true;
        b=false;
        expect(a).toBe(true);
        expect(b).toBe(true);
    })
 })
Matchers

Matcher达成了断言的可比操作,将expectation传入的实际值和Matcher传入的冀望值举办相比,得出断言的结果true
or false;

否认断言:任何Matcher都能透过在expect调用Matcher前拉长
not来具体否定断言;

describe("Included matchers:", function() {

        it("The 'toBe' matcher compares with ===", function() {
            var a = 12;
            var b = a;

            expect(a).toBe(b);
            expect(a).not.toBe(null);
        });  
        //上面的例子,比较a、b是否相等;验证a是否不是空。 

        it("should work for objects", function() {
            var foo = {
                a: 12,
                b: 34
            };
            var bar = {
                a: 12,
                b: 34
            };
            expect(foo).toEqual(bar);
        });
        //上面的例子比较了两个对象是否相等
    });

    it("The 'toMatch' matcher is for regular expressions", function() {
        var message = 'foo bar baz';

        expect(message).toMatch(/bar/);
        expect(message).toMatch('bar');
        expect(message).not.toMatch(/quux/);
    });
    //也可以使用正则表达式
    it("The 'toBeDefined' matcher compares against `undefined`", function() {
        var a = {
            foo: 'foo'
        };

        expect(a.foo).toBeDefined();
        expect(a.bar).not.toBeDefined();
    });
    //验证变量是否被定义  

    it("The 'toBeNull' matcher compares against null", function() {
        var a = null;
        var foo = 'foo';

        expect(null).toBeNull();
        expect(a).toBeNull();
        expect(foo).not.toBeNull();
    });
    //验证是否为空

    it("The 'toBeTruthy' matcher is for boolean casting testing", function() {
        var a, foo = 'foo';

        expect(foo).toBeTruthy();
        expect(a).not.toBeTruthy();
    });

    it("The 'toBeFalsy' matcher is for boolean casting testing", function() {
        var a, foo = 'foo';

        expect(a).toBeFalsy();
        expect(foo).not.toBeFalsy();
    });
    //变量是否能够转化成boolean变量? 不太确定

    it("The 'toContain' matcher is for finding an item in an Array", function() {
        var a = ['foo', 'bar', 'baz'];

        expect(a).toContain('bar');
        expect(a).not.toContain('quux');
    });
    //是否包含
    it("The 'toBeLessThan' matcher is for mathematical comparisons", function() {
        var pi = 3.1415926, e = 2.78;

        expect(e).toBeLessThan(pi);
        expect(pi).not.toBeLessThan(e);
    });

    it("The 'toBeGreaterThan' is for mathematical comparisons", function() {
        var pi = 3.1415926, e = 2.78;

        expect(pi).toBeGreaterThan(e);
        expect(e).not.toBeGreaterThan(pi);
    });
    //数学大小的比较

    it("The 'toBeCloseTo' matcher is for precision math comparison", function() {
    var pi = 3.1415926, e = 2.78;

    expect(pi).not.toBeCloseTo(e, 2);
    expect(pi).toBeCloseTo(e, 0);
    });
    //两个数值是否接近,这里接近的意思是将pi和e保留一定小数位数后,是否相等。(一定小数位数:默认为2,也可以手动指定)

    it("The 'toThrow' matcher is for testing if a function throws an exception", function() {
        var foo = function() {
        return 1 + 2;
        };
        var bar = function() {
            return a + 1;
        };

        expect(foo).not.toThrow();
        expect(bar).toThrow();
        });
    }); 
    //测试一个方法是否抛出异常  
Setup和Teardown方法

为了削减重复性的代码,jasmine提供了beforeEachafterEachbeforeAllafterAll方法。

  • beforeEach() :在describe函数中每种Spec执行此前实施;
  • afterEach() :在describe函数中各类Spec执行之后执行;
  • beforeAll() :在describe函数中拥有的Specs执行从前实施,且只进行3回
  • afterAll () : 在describe函数中具有的Specs执行之后执行,且只实行三遍

describe("A spec (with setup and tear-down)", function () {
    var foo;    
    //beforeAll 在所有的it方法执行之前执行一次
    beforeAll(function () { 
           foo = 1;       
          console.log("beforeAll run");   
   });    

   //afterAll 在所有的it方法执行之后执行一次
    afterAll(function () {       
        foo = 0;        
        console.log("afterAll run");   
    });   

  //beforeEach 在每个it方法执行之前都执行一次
   beforeEach(function () {        
        console.log("beforeEach run");   
   });    

 //afterEach 在每个it方法执行之后都执行一次
  afterEach(function () {        
      console.log("afterEach run");    
  });    

  it("is just a function,so it can contain any code", function () {       
       expect(foo).toEqual(1);    
  });   

  it("can have more than one expectation", function () {
       expect(foo).toEqual(1);
       expect(true).toEqual(true);    
  });
});

上面代码在浏览器控制台的出口

图片 36

beforeEach,beforeAll等方法执行各类输出

很明显

  • beforeAll和afterAll在八个it执行前后,总的只进行了二遍;
  • beforeEach,afterEach在历次it执行前后,都履行了三回,所以结果打字与印刷了一遍beforeEach run
    afterEach run
describe函数的嵌套

describe函数能够嵌套,嵌套中的每层都得以定义Specs(测试点)、beforeEach以及afterEach函数;

施行内层Spec时,会按嵌套由外到内的顺序执行种种beforeEach函数(所以内层Spec能够访问外层Spec中的beforeEach中的数据),其余当内层Spec执行完后,会按由内到外的逐壹执行种种afterEach函数;

describe("A spec", function () {
    var foo;
    beforeAll(function () {
        console.log("outer beforeAll");
    });

    afterAll(function () {
        console.log("outer afterAll");
    });

    beforeEach(function () {
        foo = 0;
        foo += 1;
        console.log("outer beforeEach");
    });

    afterEach(function () {
        foo = 0;
        console.log("outer afterEach");
    });

    it("is just a function, so it can contain any code", function () {
        expect(foo).toEqual(1);
    });   

   it("can have more than one expectation", function () {
        expect(foo).toEqual(1);
        expect(true).toEqual(true);
    });

    describe("nested inside a second describe", function () { 
       var bar;
        beforeAll(function () {
            console.log("inner beforeAll");
        });
        beforeEach(function () {
            bar = 1;
            console.log("inner beforeEach")
        });
        it("can reference both scopes as needed", function () {
            expect(foo).toEqual(bar);
        })
    })
});

1样,代码在浏览器控制台有出口

图片 37

嵌套describe,beforeEach、befroreAll等实施顺序输出

自定义Matchers

自定义Matcher是贰个函数,该函数再次回到贰个闭包,该闭包实质是1个compare函数,compare经受1个参数:actual
value(expect传入的实际值)和expected value(matcher函数字传送播的期望值);

compare函数必须回到三个带pass属性的Object,pass属性值是二个boolean值,表示Matcher的结果,换句话说,实际值和期望值比较的结果,存放在pass属性中;

测试退步的提示音讯能够因此Object的message属性来定义,借使没概念message信息再次来到,则会jasmine会生成1个暗中同意的错误消息提醒;

var customMatchers = {
    toBeGoofy: function (util, customEqualityTesters) {
        return {
            compare: function (actual, expected) {
                if (expected === undefined) {
                    expected = '';
                }
                console.log(util);
                console.log(customEqualityTesters);
                var result = {}; 

                //比较结果true or false 通过pass 属性值返回
                result.pass = util.equals(actual.hyuk, "gawrsh" + expected, customEqualityTesters); 

                //messge定义
                if (result.pass) {
                    result.message = "Expected" + actual + "not to be quite so goofy";
                } else {
                    result.message = "Expected" + actual + "to be goofy,but it was not very goofy"; 
               }
                return result;
            }
        };
  }};

自定义Matcher构造函数接受七个参数,util:给Matcher使用的1组织工作具函数(equals,contains,buildFailureMessage)
;customEqualityTesters:调用util.equals时须求传入,仅此而已

自定义Matchers的使用

在概念完Matcher之后,就是采纳它了。有三种接纳Matcher的法子:

  • 将Matcher函数添加到特定describe函数的beforeEach中,方便该describe函数中的Spec都能调用获得它。别的非嵌套describe中的Spec是无力回天调用到它的;

describe("Custom matcher: 'toBeGoofy'", function() {
     beforeEach(function() {
        jasmine.addMatchers(customMatchers);
 });

 it("can take an 'expected' parameter", function() {
       expect({
            hyuk: 'gawrsh is fun'
          }).toBeGoofy(' is fun');
    });
});
  • 除此以外壹种是将Matcher函数添加到全局beforeEach函数中,那样有着的Suites中的全体的Specs,都能够利用该Matcher。下边包车型大巴例子引用自官方example

//定义
beforeEach(function () {
  jasmine.addMatchers({
    toBePlaying: function () {
      return {
        compare: function (actual, expected) {
          var player = actual; 
         return {
            pass: player.currentlyPlayingSong === expected && player.isPlaying
          };
        }
      };
    }
  });
});

//应用
describe("Player", function() {
   it("should be able to play a Song", function() {
     player.play(song);
     //demonstrates use of custom matcher
     expect(player).toBePlaying(song);
 });

 describe("when song has been paused", function() {
     it("should indicate that the song is currently paused",   function() {
     // demonstrates use of 'not' with a custom matcher
       expect(player).not.toBePlaying(song);
     });
)};
我的jasmine gitstart

https://github.com/unnKoel/jasmine-gitstart

参考

github
jasmine

关于前端开发谈谈单元测试

JavaScript单元测试框架-Jasmine
Javascript测试框架Jasmine(4):自定义Matcher
jasmine测试框架简介
JavaScript 单元测试框架:Jasmine初探