Javascript 测试框架 Jasmine（二）：Matchers

上一篇稍微介绍了一下，这一篇讲讲 Matcher。在 Jasmine 中，每个 Matcher 实现一个“期望值”和“实际值”的布尔判断，Jasmine 会根据 Mather 判断 expectation 是true 还是false ，然后决定 spec 是测试通过还是失败。所有 Matcher 可以通过not 执行否定判断。例如：

it('not示例', function () {
  expect(false).not.toBe(true)
})

Jasmine 提供了丰富的内置 Matchers，下面简单讲一下：

toBe#

toBe Matcher 用来执行=== 对比：

it('toBe Matcher用来执行===对比', function () {
  var a = 12
  var b = a

  expect(a).toBe(b)
  expect(a).not.toBe(null)
})

在线执行

toEqual#

判断两个对象是否相等，可以对比简单的值类型的变量和对象：

describe('toEqual判断两个对象是否相等：', function () {
  it('对比简单的值类型的变量', function () {
    var a = 12
    expect(a).toEqual(12)
  })

  it('对比对象', function () {
    var foo = {
      a: 12,
      b: 34,
    }
    var bar = {
      a: 12,
      b: 34,
    }
    expect(foo).toEqual(bar)
  })
})

在线执行

toMatch#

使用正则匹配：

it('toMatch用来进行正则匹配', function () {
  var message = 'foo bar baz'

  expect(message).toMatch(/bar/)
  expect(message).toMatch('bar')
  expect(message).not.toMatch(/quux/)
})

在线执行

toBeDefined#

判断是否非undefined：

it('toBeDefined判断是否非undefined', function () {
  var a = {
    foo: 'foo',
  }

  expect(a.foo).toBeDefined()
  expect(a.bar).not.toBeDefined()
})

在线执行

toBeUndefined#

判断是否是 undefined：

it('toBeUndefined判断是否是undefined', function () {
  var a = {
    foo: 'foo',
  }

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

在线执行

toBeNull#

判断是否为 null：

it('toBeNull用来判断是否为null', function () {
  var a = null
  var foo = 'foo'

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

在线执行

toBeTruthy#

布尔测试，判断值是否是，或者可以转换为 true：

it('toBeTruthy执行布尔测试，判断值是否是，或者可以转换为true', function () {
  var a,
    foo = 'foo'

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

在线执行

toBeFalsy#

布尔测试，于 toBeTruthy 相反：

it('toBeFalsy和toBeTruthy相反', function () {
  var a,
    foo = 'foo'

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

在线执行

toContain#

判断一个数组是否包含某个值：

it('toContain判断一个数组是否包含某个值', function () {
  var a = ['foo', 'bar', 'baz']

  expect(a).toContain('bar')
  expect(a).not.toContain('quux')
})

在线执行

toBeLessThan#

数字大小比较：

it('toBeLessThan执行数字大小比较', function () {
  var pi = 3.1415926,
    e = 2.78

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

在线执行

toBeGreaterThan#

和 toBeLessThan 相反：

it('toBeGreaterThan和toBeLessThan相反', function () {
  var pi = 3.1415926,
    e = 2.78

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

在线执行

toBeCloseTo#

前面都作用一目了然，这个就有一点点不还理解了，还是想看例子：

it('toBeCloseTo示例', function () {
  var pi = 3.1415926,
    e = 2.78

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

再看看它的源码：

getJasmineRequireObj().toBeCloseTo = function () {
  function toBeCloseTo() {
    return {
      compare: function (actual, expected, precision) {
        if (precision !== 0) {
          precision = precision || 2
        }

        return {
          pass: Math.abs(expected - actual) < Math.pow(10, -precision) / 2,
        }
      },
    }
  }

  return toBeCloseTo
}

这下就比较清晰了，toBeCloseTo 是比较两个值是否足够接近（不一定要相等），而这个“足够接近”就是toBeCloseTo 的第二个参数指定的，它表示小数点后位数除以 2（Math.pow(10, -precision) / 2 ）。

在线执行

toThrow#

判断一个函数是否有抛出异常：

it('toThrow判断一个函数是否有抛出异常', function () {
  var foo = function () {
    return 1 + 2
  }
  var bar = function () {
    return a + 1 //a不存在
  }

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

在线执行

– 下一篇讲一下 Setup、Teardown、嵌套 describe、禁用 Suites，Specs 等 –