Karma

最近的项目在使用AngulaJs,对JS代码的测试问题就摆在了面前。

通过对比我们选择了

Karma

https://github.com/jasmine/jasmine/releases

选择最新版本下载下来示例代码结构如图

开始于调用全局Jasmine函数describe有两个参数一个字符串和一个函数。

describe(A

expect(message).toMatch(/bar/);

expect(message).not.toMatch(/quux/);

});

expect(a.bar).not.toBeDefined();

});

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

});

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

});

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

});

expect(foo).toThrowError(/bar/);

expect(foo).toThrowError(TypeError);

expect(foo).toThrowError(TypeError,

foo

string参数用于命名specs的集合并且将与specs连接以构成spec的全名。

//这有助于在

beforeEachafterEachbeforeAll和afterAll函数

//顾名思义beforeEach函数在调用它的describe中的每个

spec

之前调用一次afterEach函数在每个spec之后调用一次。

被测变量定义在顶层作用域

//beforeAll函数仅在describe中的所有specs(测试用例)运行之前调用一次并且afterAll函数在所有specs(测试用例)完成后调用。

由于它们不在specs(测试用例)之间重置很容易在specs(测试用例)之间意外泄漏状态

注意跟

//另一种在beforeEachit和afterEach之间共享变量的方法是通过this关键字。

afterEach都将这个作为同一个空对象对于下一个spec的beforeEach

describe(A

expect(this.bar).toBe(undefined);

});

//调用describe可以嵌套在任何级别定义specs(测试用例)。

//在执行specs(测试用例)之前Jasmine沿着树顺序执行每个beforeEach函数。

afterEach

//在没有函数体的情况下声明的任何specs(测试用例)也将在结果中被标记为待处理

it(can

如果你在specs(测试用例)体中任何地方调用该函数无论预期如何specs(测试用例)将被标记为待定。

//pending()函数接受一个字符串参数该参数会在结果集中显示在

PENDING

只存在于描述或其定义的块中并且将在每个specs(测试用例)之后删除。

spies

expect(foo.setBar).toHaveBeenCalled();

});

被调用了指定的次数toHaveBeenCalledTimes匹配器将通过。

it(tracks

expect(foo.setBar).toHaveBeenCalledTimes(2);

});

toHaveBeenCalledWith匹配器将返回true。

it(tracks

expect(foo.setBar).toHaveBeenCalledWith(123);

expect(foo.setBar).toHaveBeenCalledWith(456,

ano***r

expect(foo.getBar).toHaveBeenCalled();

});

expect(fetchedBar).toEqual(123);

});

expect(foo.getBar).toHaveBeenCalled();

});

expect(fetchedBar).toEqual(745);

});

//直到它到达返回值列表的结尾此时它将返回未定义的所有后续调用。

describe(A

getBar).and.returnValues(fetched

first,

expect(foo.getBar).toHaveBeenCalled();

});

expect(foo.getBar()).toEqual(fetched

first);

expect(foo.getBar()).toEqual(fetched

second);

expect(foo.getBar()).toBeUndefined();

});

getBar).and.callFake(function(arguments,

can,

expect(foo.getBar).toHaveBeenCalled();

});

expect(fetchedBar).toEqual(1001);

});

//.calls.any如果spy没有被调用则返回false如果至少有一个调用发生则返回true

it(tracks

expect(foo.setBar.calls.any()).toEqual(false);

foo.setBar();

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

});

expect(foo.setBar.calls.count()).toEqual(0);

foo.setBar();

expect(foo.setBar.calls.count()).toEqual(2);

});

//.calls.argsForindex返回传递给调用号索引的参数

it(tracks

expect(foo.setBar.calls.argsFor(0)).toEqual([123]);

expect(foo.setBar.calls.argsFor(1)).toEqual([456,

baz]);

expect(foo.setBar.calls.allArgs()).toEqual([[123],[456,

baz]]);

//.calls.all返回上下文this和传递所有调用的参数

it(can

expect(foo.setBar.calls.all()).toEqual([{object:

foo,

//.calls.mostRecent返回上一次调用的上下文this和参数

it(has

expect(foo.setBar.calls.mostRecent()).toEqual({object:

foo,

//.calls.first返回上下文this和第一次调用的参数

it(has

expect(foo.setBar.calls.first()).toEqual({object:

foo,

//当检查来自allmostRecent和first的返回时当调用

specs

expect(spy.calls.first().object).toBe(baz);

expect(spy.calls.mostRecent().object).toBe(quux);

});

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

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

});

//当没有一个函数来监视jasmine.createSpy可以创建一个“裸”

specs

expect(whatAmI.and.identity()).toEqual(whatAmI);

});

expect(whatAmI).toHaveBeenCalled();

});

expect(whatAmI.calls.count()).toEqual(1);

});

expect(whatAmI).toHaveBeenCalledWith(I,

am,

expect(whatAmI.calls.mostRecent().args[0]).toEqual(I);

});

的模拟使用jasmine.createSpyObj并传递一个字符串数组。

它返回一个对象它具有属于

expect(tape.play).toBeDefined();

expect(tape.pause).toBeDefined();

expect(tape.stop).toBeDefined();

expect(tape.rewind).toBeDefined();

});

expect(tape.play).toHaveBeenCalled();

expect(tape.pause).toHaveBeenCalled();

expect(tape.rewind).toHaveBeenCalled();

expect(tape.stop).not.toHaveBeenCalled();

});

expect(tape.rewind).toHaveBeenCalledWith(0);

});

//如果实际值不为null或未定义jasmine.anything返回true。

it(matches

expect(1).toEqual(jasmine.anything());

});

expect(foo).toHaveBeenCalledWith(12,

jasmine.anything());

//与jasmine.objectContaining的部分匹配

//jasmine.objectContaining是用于期望在实际中只关心某些键/值对的时候。

describe(jasmine.objectContaining,

function()

expect(foo).toEqual(jasmine.objectContaining({

bar:

expect(foo).not.toEqual(jasmine.objectContaining({

}));

expect(callback).toHaveBeenCalledWith(jasmine.objectContaining({

bar:

expect(callback).not.toHaveBeenCalledWith(jasmine.objectContaining({

}));

//部分数组与jasmine.arrayContaining相匹配

//jasmine.arrayContaining用于那些期望只关心数组中的某些值的时候。

describe(jasmine.arrayContaining,

function()

expect(foo).toEqual(jasmine.arrayContaining([3,

1]));

expect(foo).not.toEqual(jasmine.arrayContaining([6]));

});

expect(callback).toHaveBeenCalledWith(jasmine.arrayContaining([4,

3]));

expect(callback).not.toHaveBeenCalledWith(jasmine.arrayContaining([5,

2]));

//jasmine.stringMatching用于当你不想完全匹配较大对象中的字符串时或者匹配

specs

describe(jasmine.stringMatching,

function()

jasmine.stringMatching(/^bar$/)});

expect({foo:

expect(callback).toHaveBeenCalledWith(jasmine.stringMatching(bar));

expect(callback).not.toHaveBeenCalledWith(jasmine.stringMatching(/^bar$/));

});

//当您需要检查某个满足特定标准的条件而不是严格相等时您还可以通过提供具有asymmetricMatch函数的对象来指定自定义非对称等式测试器。

describe(custom

expect(foo,bar,baz,quux).toEqual(tester);

});

expect(callback).toHaveBeenCalledWith(tester);

});

jasmine.clock。

安装在需要操纵时间的spec或suite。

timerCallback

jasmine.createSpy(timerCallback);

});

//您可以使setTimeout或setInterval同步执行已注册的函数只有当时钟在时间上向前跳过时。

//要执行注册的函数通过jasmine.clock。

tick函数延时时间该函数

参数为

expect(timerCallback).not.toHaveBeenCalled();

expect(timerCallback).toHaveBeenCalled();

});

expect(timerCallback).not.toHaveBeenCalled();

expect(timerCallback.calls.count()).toEqual(1);

expect(timerCallback.calls.count()).toEqual(1);

expect(timerCallback.calls.count()).toEqual(2);

});

//如果你没有为mockDate提供基准时间它将使用当前日期。

jasmine.clock().mockDate(baseTime);

expect(new

Date().getTime()).toEqual(baseTime.getTime()

50);

Jasmine还支持运行需要测试异步操作的specs(测试用例)。

specs,

//调用beforeAllafterAllbeforeEachafterEach和它可以接受一个可选的单个参数当异步工作完成时应该调用。

value

//在done函数在调用之前这个specs(测试用例)不会开始。

//这个specs(测试用例)将会等待

expect(value).toBeGreaterThan(0);

expect(value).toBe(1);//所以这里value

done();

//默认情况下jasmine将等待5秒钟异步specs(测试用例)在导致超时失败之前完成。

//如果超时在调用done之前超时则当前specs(测试用例)将被标记为失败并且单元测试执行将继续如同调用完成。

//如果特定规则应该更快失败或需要更多时间可以通过向其传递超时值等来调整。

//如果整个单元测试应该有不同的超时则可以在任何给定描述之外全局设置jasmine.DEFAULT_TIMEOUT_INTERVAL。

describe(long

//done.fail函数使specs(测试用例)失败并指示它已完成

describe(A

//这个工厂被传递给Jasmine理想的情况是调用beforeEach并且在一个给定的调用中描述的所有规范的范围内。

var

//自定义匹配器工厂传递两个参数util它有一组用于匹配器使用的效用函数见matchersUtil.js用于当前列表和customEqualityTesters

toBeGoofy:

//工厂方法应该返回一个含有比较函数的对象该函数将被调用以检查期望值。

return

//toBeGoofy接受一个可选的期望参数所以如果不传递在这里定义。

(expected

jasmine.addMatchers(customMatchers);

});