jest里的相配器,学习笔记

  Jest官方网站地址  

您也足以采取Jest的“相称器”来测试数据。有许多不一的相称器,所以那篇文章只会介绍最常用的二种。

基本概念


  Jest是特意被facebook用于测试包涵React应用在内的具备javascript代码,Jest目的在于提供一个综合的零总括的测试体验。

日常相称

suites

suites表示叁个测试集,以函数describe封装

因为未有找到文书档案,基于本身个人的经历,Jest是要在babel情况下手艺够使用的,所以请查看babel官方网站首页学习babel安装情势。

最简易的的测试方法便是看几个比较值是还是不是等于:

describe

describe 是 Jasmine 的大局函数,作为二个 Test Suite 的伊始
它一般有 2 个参数:字符串和措施
字符串 -> 特定 Suite 的名字和标题
方法 -> 实现 Suite 的代码

describe("This is an exmaple suite", function() {
  it("contains spec with an expectation", function() {
    //测试true是否等于true
    expect(true).toBe(true);
    expect(false).toBe(false);
    expect(false).not.toBe(true);
  });
});

设置jest,在调控台的品类所在文件夹输入下列代码:

test(‘2加2等于’,()=>{
    expect(2+2).toBe(4);
});

Specs

Specs 通过调用 it 的大局函数来定义
it和describe的参数同样
每一种 Spec 包蕴三个或多个 expectations 来测试须求测试代码

npm install –save-dev jest 或者 yarn add –dev jest

在那段代码中,expect(二 + 2)
重回一个“expectation”对象。针对expectation对象,你除了调用相配器,别的的您怎么样也做不了。在那段代码中,.toBe(四)正是相称器。当Jest运转时,它会追踪全体的相配器,借使有曲折的合作就能够打字与印刷出荒谬音讯。

Expectations

Expectations 是由艺术 expect 来定义
1值代表实际值,贰值代表希望值

在package.json中配置:

把toBe换来===效果是均等的。假使您想检查一个指标的值,那么快要用 toEqual
来替代了:

Matchers

Matcher达成了断言的可比操作
能够在expect调用Matcher前拉长not来完成一个否认的断言(expect(a).not.toBe(false);)
常见的matchers:
toBe():相当于===比较
toNotBe()
toBeDefined():检查变量或质量是还是不是已扬言且赋值
toBeUndefined()
toBeNull():是否是null
toBeTruthy():假如调换为布尔值,是还是不是为true
toBeFalsy()
toBeLessThan():数值比较,小于
toBeGreaterThan():数值相比,大于
toEqual():相当于==

注意与toBe()的区别:
一个新建的Object不是(not to be)另一个新建的Object,但是它们是相等(to equal)的

toNotEqual()
toContain():数组中是还是不是含有成分(值)只可以用于数组,无法用来对象
toBeCloseTo():数值相比较时定义精度,先四舍5入后再比较

//true
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);
});

toHaveBeenCalled()
toHaveBeenCalledWith()
toMatch():按正则表明式匹配
toNotMatch()
jest里的相配器,学习笔记。toThrow():核准二个函数是不是会抛出贰个不当

{
  "scripts": {
    "test": "jest"
  }

}

test(‘对象分配属性’,()=>{
    const data={one:1};
    data[‘two’]=2;
    expect(data).toEqual({one:1,two:2});
});

Setup and Teardown

Jasmine 提供了全局的措施完结清理操作
在describe函数中,
beforeEach():各样Spec实施在此以前推行
afterEach(): 各种Spec实行之后实行。
beforeAll():全数的Specs试行以前实践,但只进行三回
afterAll():全体的Specs推行之后施行,但只进行贰次

  

toEqual 会递归的自己争持数;组或对象的每五个地点。

嵌套代码块

describe 能够嵌套, Specs 能够定义在任何一层
多个 suite 能够由①组树状的措施结合
在每种 spec 施行前,Jasmine 遍历树结构,按顺序实施种种 beforeEach
方法,Spec 实施后,Jasmine 同样实行相应的 afterEach

你可以利用Jest中的“matchers”去测试代码,以下将介绍最常用的matchers.

您同一能够张开反向测试:

跳过测试代码块

Suites 和 Specs 分别能够用 xdescribe 和 xit 方法来剥夺和挂起
被Disabled的Suites在施行中会被跳过,该Suite的结果也不会来得在结果聚焦
被Pending的Spec不会被实践,不过Spec的名字会在结果集中展现,只是标识为Pending

xdescribe("An example of xdescribe.", function() {
  var gVar;

  beforeEach(function() {
    gVar = 3.6;
    gVar += 1;
  });

  xit(" and xit", function() {
    expect(gVar).toEqual(4.6);
  });
});

三个平素不定义函数体的Sepc也会在结果聚焦被标识为Pending
万一在Spec的函数体中调用pending()函数,那么该Spec也会被标识为Pending。pending()函数接受1个字符串参数,该参数会在结果聚集呈现在PENDING
WITH MESSAGE:之后,作为为啥被Pending的案由

describe("Pending specs", function() {

  xit("can be declared 'xit'", function() {
    expect(true).toBe(false);
  });

  it("can be declared with 'it' but without a function");

  it("can be declared by calling 'pending' in the spec body", function() {
    expect(true).toBe(false);
    pending('this is why it is pending');
  });
});
test('two plus two is four', () => {
  expect(2 + 2).toBe(4);
});

test(‘正数相加不为零’,()=>{
    for(let a=1;a<10;a++){
        for(let b=1;b<10;b++){
            expect(a+b).not.toBe(0);
        }
    }
});

Spy

Spy能监测任何function的调用和格局参数的调用印迹。需利用一个新鲜的Matcher:

  • toHaveBeenCalled:能够检查function是或不是被调用过
  • toHaveBeenCalledWith: 能够检查传入参数是还是不是被看成参数调用过

spyOn
使用 spyOn(obj,'function') 来为 obj 的 function 方法声圣元(Synutra)个Spy
对Spy函数的调用并不会影响真实的值

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() { 
      // Spy的调用并不会影响真实的值,所以bar仍然是null
      expect(bar).toBeNull(); 
    });
});

and.callThrough
借使在spyOn之后链式调用and.callThrough,那么Spy除了追踪全体的函数调用外,还会一贯调用函数额真实完成,因而Spy再次来到的值便是函数调用后实在的值了

  ... 
  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 effect other functions", function() { 
    expect(bar).toEqual(123); 
  }); 
  it("when called returns the requested value", function() { 
    expect(fetchedBar).toEqual(123); 
  });
});

and.stub
在调用and.callThrough后,假使您想阻止spi继续对实际值发生潜移默化,你能够调用and.stub。也正是说,and.stub是将spi对实际落到实处的震慑还原到最后的状态——不影响实际值

spyOn(foo, 'setBar').and.callThrough();
foo.setBar(123);
// 实际的bar=123
expect(bar).toEqual(123);
// 调用and.stub()后,之后调用foo.setBar将不会影响bar的值。
foo.setBar.and.stub();
foo.setBar(456);
expect(bar).toBe(123);
bar = null;
foo.setBar(123);
expect(bar).toBe(null);

以上代码为jest的书写格局,expect(2+二) 回来一个“expectation”对象,你除了调用那些目标,平时不会有太多其余的操作。toBe(4) 正是matcher。

重重时候测试需求区分
undefined,null和false,可是你有不想做那些艰辛的事。那jest已经为您策动好了重重入手方法律专科高校门消除那一个标题。
— toBeNull 只匹配 null
— toBeUndefined 只匹配 undefined
— toBeDefined 是 toBeUndefined 的反相称
— toBeTruthy 相配 if 语句期望获取 true 的
— toBeFalsy 相配 if 语句期望获取 false 的

大局相称谓词


jasime.any
参数为贰个构造函数,用于检查实验该参数是不是与实际值所对应的构造函数相匹配

describe("jasmine.any", function() { 
  it("matches any value", function() { 
    expect({}).toEqual(jasmine.any(Object)); 
    expect(12).toEqual(jasmine.any(Number)); 
  }); 
  describe("when used with a spy", function() { 
    it("is useful for comparing arguments", function() { 
      var foo = jasmine.createSpy('foo'); 
      foo(12, function() { return true; }); 
      expect(foo).toHaveBeenCalledWith(jasmine.any(Number), jasmine.any(Function)); 
    }); 
  });
});

jasime.anything
用来检查实验实际值是或不是为 null 或 undefined ,要是不为 null 或
undefined,则赶回true

it("matches anything", function() { 
  expect(1).toEqual(jasmine.anything());
});

jasmine.objectContaining
用来检查实验实际Object值中是还是不是存在一定key/value对。

var foo;
beforeEach(function() {
  foo = {
    a: 1,
    b: 2,
    bar: "baz"
  };
 });
it("matches objects with the expect key/value pairs", function() {
  expect(foo).toEqual(jasmine.objectContaining({ bar: "baz" }));
  expect(foo).not.toEqual(jasmine.objectContaining({ c: 37 }));
});

jasmine.arrayContaining
用来检验实际Array值中是或不是留存特定值。


.not:举例:expect(value).not.toBe(2);
只要value不等于2就ok.

举个例证:

this值

除外在describe函数开首定义变量,用于各it函数共享数据外,还足以经过this关键字来共享数据。
在在每三个Spec的生命周期(beforeEach->it->afterEach)的开端,都将有2个空的this对象(在始发下一个Spec周期时,this会被复位为空对象)。

toBe(value):用 === 来测试完全相等

test(‘null’,()=>{
    const n=null;
    expect(n).toBeNull();
    expect(n).toBeDefined();
    expect(n).not.toBeUndefined();
    expect(n).not.toBeTruthy();
    expect(n).toBeFalsy();
});
test(‘0’,()=>{
    const z=0;
    expect(z).not.toBeNull();
    expect(z).toBeDefined();
    expect(z).not.toBeUndefined();
    expect(z).not.toBeTruthy();
    expect(z).toBeFalsy();
});

参照目录


JavaScript 单元测试框架:Jasmine初探
JavaScript单元测试框架-Jasmine
web前端开拓7武器—Jasmine入门教程(上)

toEqual(object):  测试目的是或不是等于。

您应有依附你的代码来挑选最好的相配器。

toBeNull(): 只匹配Null

数字的相比都用相应的相配器。

toBeUndefined(): 只匹配undefined

test(‘2加2’,()=>{
    const value=2+2;
    expect(value).toBeGreaterThan(3);//大于相称器
    expect(value).toBeGreaterThanOrEqual(三.伍);//大于或等于相称器
    expect(value).toBeLessThan(伍);//小于相称器
    expect(value).toBeLessThanOrEqual(四.伍);//小于或等于相配器
    // toBe 和 toEqual 对数字来说效果十三分
    expect(value).toBe(4);
    expect(value).toEqual(4);
});

toBeFalsy():相称假。0和null都为假哦。

只要您不指望浮点数的测试存在模型误差,请使用 toBeCloseTo 来顶替 toEqual。

toBeCloseTo(浮点数):浮点数的可比。不可能选拔toEqual().

test(‘浮点数相加’,()=>{
    const value=0.1+0.2;
    expect(value).not.toBe(0.三);// 错误的措施,因为存在相对误差。
    expect(value).toBeCloseTo(0.叁);// 精确的情势。
});

toMatch():相配字符串中是或不是留存字符,与正则表明式搭配使用。expect(‘克里Stowe夫’).toMatch(/stop/);

对于字符串你能够应用 toMatch 同盟正则表明式。

澳门葡京,toContain(数组里的value): 数组是不是包罗某特定子项。不过不能够测试数组里是还是不是带有某1数组。

test(‘team 中没有 i ‘,()=>{
    expect(‘team’).not.toMatch(/I/);
});
test(‘但是 Christoph 中有 stop’,()=>{
    expect(‘Christoph’).toMatch(/stop/);
});

toThrow():
因为怎么用错误管理,没太看懂。原版的书文:假诺您想要测试的一定函数抛出多个谬误,在它调用时,使用 toThrow

测试数组是或不是带有特定的要素得以采纳 toContain。

extend(matchers): 将本身的相称器增添到Jest。

const shoppingList=[
    ‘diapers’,
    ‘kleenex’,
    ‘trash bags’,
    ‘paper towels’,
    ‘beer’,
];
test(‘shopping 列队是有 beer 的’,()=>{
    expect(shoppingList).toContain(‘beer’);
});

  matcher中的有二个生死攸关字pass来定义测试成功与否。

假诺你想测试有些函数被调用的时候是或不是会抛出荒唐,请使用 toThrow。

  this.isNot(); this.equals(a,
b);

function compileAndroidCode(){
    throw new ConfigError(‘你利用了错误的JDK’);
}
test(‘编译 android’,()=>{
    expect(compileAndroidCode).toThrow();
    expect(compileAndroidCode).toThrow(ConfigError);
    // 你还足以同盟完整的荒谬新闻或正则表达式
    expect(compileAndroidCode).toThrow(‘你利用了错误的JDK’);
    expect(compileAndroidCode).toThrow(/JDK/);
});

  this.utils(); 上的一些工具根本由jest-matcher-utils导出,最常用的是 matcherHint();
printReceived();

  jest官方建议:在写自个儿的matcher时,最棒是能尽量地付出详细的消息以便于使用者能异常快的改进错误。

anything():相称除了
null 和 undefined 的值。

any(constructor):生成狂妄的该类型数据。

  any(Number)的重回值:

 

Any {
'$$typeof': Symbol(jest.asymmetricMatcher),
sample: [Function: Number] }

 

arrayContaining(array):和any(construcor)类似。

assertions(number):确认断言函数被调用的次数。常用来测试异步函数,确认保障回调函数内的断言函数确实被调用。

hasAssertions():用于确认至少有三个断言函数被调用。常用于测试异步函数,确认保证有回调函数确实被调用。

objectContaining(object):用于决断三个目的是不是带有在另一指标中,测试3个对象是或不是调用了某艺术也能够用此格局。(没太看懂怎么使用) 

stringContaining(string):一个字符串是或不是带有另三个字符串。仅用于jest
1九.0.0+。

stringMatching(regexp):字符串匹配正则表明式。

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website